## generated by RPythonic 0.3.6pre4
## http://code.google.com/p/rpythonic/
import os, sys, ctypes
IS32BIT = (ctypes.sizeof(ctypes.c_void_p)==4)

## this ctypes file expects to be in the cache directory, 
## with precompiled c-libraries two directories up, if the library is not there try to load from the system.
_clibs_dir = os.path.join( os.path.dirname(os.path.abspath(__file__)), '../../clibs' )
_clibs_dir = os.path.abspath( _clibs_dir )

def _load_ctypes_lib( name ):
	if os.name == 'posix':
		if sys.platform=='linux2':
			name += '.so'
			if IS32BIT: 	path = os.path.join(_clibs_dir,'linux32')
			else: 		path = os.path.join(_clibs_dir,'linux64')
			url = os.path.join( path, name )
			if os.path.isfile( url ): return ctypes.CDLL(url)
			elif os.path.isfile( '/usr/local/lib/%s'%name ): return ctypes.CDLL('/usr/local/lib/%s'%name)
			elif os.path.isfile( '/usr/local/lib64/%s'%name ) and not IS32BIT: return ctypes.CDLL('/usr/local/lib64/%s'%name)
			elif os.path.isfile( '/usr/lib/%s'%name ): return ctypes.CDLL('/usr/lib/%s'%name)
			elif os.path.isfile( './%s'%name ): return ctypes.CDLL('./%s'%name)
			else: return ctypes.CDLL(name) #fallback

		elif sys.platform == 'darwin':
			name += '.dylib'
			if IS32BIT: 	path = os.path.join(_clibs_dir,'osx32')
			else: 		path = os.path.join(_clibs_dir,'osx64')
			url = os.path.join( path, name )
			if os.path.isfile( url ): return ctypes.CDLL(url)
			else: return ctypes.CDLL(name) #fallback

	elif os.name == 'nt':
		name += '.dll'
		if IS32BIT: 	path = os.path.join(_clibs_dir,'win32')
		else: 		path = os.path.join(_clibs_dir,'win64')
		url = os.path.join( path, name )
		if os.path.isfile( url ): return ctypes.CDLL(url)
		else: return ctypes.CDLL(name) #fallback

RPYTHONIC_WRAPPER_FUNCTIONS = {}
RPYTHONIC_WRAPPER_FUNCTIONS_FAILURES = []

_VOIDPP_ = ctypes.POINTER( ctypes.c_void_p )
## ctypes does not clearly expose these types ##
PyCFuncPtrType = type(ctypes.CFUNCTYPE(ctypes.c_void_p))
PyCArrayType = type( ctypes.c_int * 2 )
PyCPointerType = type( ctypes.POINTER(ctypes.c_int) )
PyCStructType = type( ctypes.Structure )
CArgObject = type( ctypes.byref(ctypes.c_int()) )

class _rpythonic_function_(object):
	def __init__(self, name, result=ctypes.c_void_p, args=[]):
		self.name = name
		self.result = result
		self.argtypes = []
		self.argnames = []
		self.argtypestypes = []
		for arg in args:
			self.argnames.append( arg[0] )
			self.argtypes.append( arg[1] )
			self.argtypestypes.append( type(arg[1]) )		# precomputed for speed
		self.argtypes = tuple( self.argtypes )
		self.argnames = tuple( self.argnames )
		self.argtypestypes = tuple( self.argtypestypes )
		self.numargs = len( self.argtypes )
		self.callbacks = [None] * self.numargs
		try:
			self.setup()
			RPYTHONIC_WRAPPER_FUNCTIONS[ name ] = self
		except:
			RPYTHONIC_WRAPPER_FUNCTIONS_FAILURES.append( name )

	def setup(self):
		func = self.function = getattr(_ctypes_lib_, self.name );
		func.restype = self.result
		func.argtypes = self.argtypes
		self.defaults = []
		for i in range( self.numargs ):
			T = self.argtypes[ i ]
			if type(T) is PyCFuncPtrType:
				p = T()	# func pointers can not be None
				self.defaults.append( p )
				self.callbacks[ i ] = p					# save reference
			else: self.defaults.append( None )	# None is allowed for all other types

	def __call__( self, *args ):			# allow flexible calling types
		cargs = list( self.defaults )
		for i,arg in enumerate(args):
			t = type(arg)
			k = self.argtypes[ i ]
			kt = self.argtypestypes[ i ]
			if t in (list,tuple):				# convert lists and tuples into array
				if kt is PyCArrayType:
					cargs[ i ] = k(*arg)
				elif kt is PyCStructType:
					if k._array_wrapper_: cargs[ i ] = k(arg)	# allow easy array init
					else: cargs[ i ] = k(*arg)							# allow multiple args
				elif kt is PyCPointerType:
					cargs[ i ] = _convert_nested_list_to_pointer( k, arg )
				else: assert 0
			#elif k is _VOIDPP_ and isinstance( arg, ctypes._Pointer ):
			#	# special case, need to cast, opaque hack
			#	cargs[ i ] = ctypes.cast( arg, _VOIDPP_ )
			elif isinstance( arg, ctypes._Pointer ) and t is not k:
				cargs[ i ] = ctypes.cast( arg, k )	# generic's that need to be cast

			elif kt is PyCPointerType and not isinstance( arg, (ctypes._Pointer,CArgObject) ):
				if t in (int,float,bool): ptr = k( k._type_(arg) )
				elif t is str:
					ptr = k( k._type_() )		# not k() otherwise null pointer error
					for j, char in enumerate(arg): ptr[ j ] = char.encode('ascii')
				elif t in (PyCStructType, PyCArrayType):
					ptr = ctypes.cast( ctypes.pointer( arg ), k )
				else:		# wrap py object
					ptr = ctypes.cast( ctypes.pointer(ctypes.py_object(arg)), k )
				cargs[ i ] = ptr
			elif kt is PyCFuncPtrType:
				cargs[ i ] = self.callbacks[ i ] = k( arg )		# assume arg is a callable
			else:
				cargs[ i ] = arg		# directly pass

		return self.function( *cargs )


def _convert_nested_list_to_pointer( k, arg ):
	depth = 0; s = k
	while True:
		if type(s) is PyCPointerType:
			s = getattr( s, '_type_' )
			depth += 1
		else: break
	assert depth and depth <= 2
	if depth == 1:
		T = k._type_
		ptr = k( k._type_() )
		for i in range( len(arg) ):
			ptr[ i ] = T( *arg[i] )
	elif depth == 2:
		T = k._type_._type_
		_ptr = k._type_( k._type_._type_() )
		for i in range(len( arg )):
			for j in range( len(arg[i]) ):
				_ptr[ j ] = T( *arg[ i ][ j ] )
		ptr = k( _ptr )
	return ptr

#setattr( ctypes._Pointer, '__call__', lambda s: s.contents )	# not allowed
#class __smart_pointer__( ctypes._Pointer ):
#	def __call__(self): return self.contents
#	def __getattr__(self, name ): return getattr( self.contents, name )
#setattr( ctypes, '_Pointer', __smart_pointer__ )		# this works!

def __freeze_rpythonic_struct( cls, fields ):
	try: setattr( cls, '_fields_', fields )
	except:
		print( 'WARN - bad order struct freeze', cls )
		#cls._fields_ = []

class _rpythonic_struct_( ctypes.Structure ):
	_array_wrapper_ = False
	_fields_ = []
	def __call__(self): return self
	def __init__(self, *args, **kw ):
		cargs = []
		argtypes = []
		for a in self._fields_: argtypes.append( a[1] )
		if len(args) > len(argtypes): args = [args]	# allow both calling conventions
		for i,arg in enumerate( args ):
			t = type(arg)
			k = argtypes[ i ]
			if t in (list,tuple):
				if k.__class__.__name__	== 'PyCArrayType':
					cargs.append( k(*arg) )
				elif k.__class__.__name__ == 'PyCStructType':
					if k._array_wrapper_: cargs.append( k(arg) )	# allow easy array init
					else: cargs.append( k(*arg) )							# allow multiple args
			elif isinstance( arg, ctypes._Pointer ) and t is not k:
				cargs[ i ] = ctypes.cast( arg, k )	# generic's that need to be cast
			elif k.__class__.__name__ == 'PyCArrayType' and t in (float,int,bool):
				cargs.append( k(arg) )		# support init array from single value
			else:
				cargs.append( arg )		# directly pass

		ctypes.Structure.__init__(self, *cargs, **kw)



_clib_name_ = 'libode'
print('loading lib', _clib_name_)
print( os.path.abspath( os.path.curdir ) )
_ctypes_lib_ = _load_ctypes_lib( _clib_name_ )
assert _ctypes_lib_
print( _ctypes_lib_._name )

## macro globals ##
## enums ##
_codecvt_result = { 
	"__codecvt_ok" : 0, 
	"__codecvt_partial" : 1, 
	"__codecvt_error" : 2, 
	"__codecvt_noconv" : 3, 
}

FP_NAN = 0 
FP_INFINITE = 1 
FP_ZERO = 2 
FP_SUBNORMAL = 3 
FP_NORMAL = 4 

IEEE_ = -1 
SVID_ = -1 
XOPEN_ = 0 
POSIX_ = 1 
ISOC_ = 2 

d_ERR_UNKNOWN = 0 
d_ERR_IASSERT = 0 
d_ERR_UASSERT = 1 
d_ERR_LCP = 2 

dJointTypeNone = 0 
dJointTypeBall = 0 
dJointTypeHinge = 1 
dJointTypeSlider = 2 
dJointTypeContact = 3 
dJointTypeUniversal = 4 
dJointTypeHinge2 = 5 
dJointTypeFixed = 6 
dJointTypeNull = 7 
dJointTypeAMotor = 8 
dJointTypeLMotor = 9 
dJointTypePlane2D = 10 
dJointTypePR = 11 
dJointTypePU = 12 
dJointTypePiston = 13 

dParamLoStop = 0 
dParamHiStop = 0 
dParamVel = 1 
dParamFMax = 2 
dParamFudgeFactor = 3 
dParamBounce = 4 
dParamCFM = 5 
dParamStopERP = 6 
dParamStopCFM = 7 
dParamSuspensionERP = 8 
dParamSuspensionCFM = 9 
dParamERP = 10 
dParamsInGroup = 11 
dParamGroup1 = 0 
dParamLoStop1 = 0 
dParamHiStop1 = 0 
dParamVel1 = 1 
dParamFMax1 = 2 
dParamFudgeFactor1 = 3 
dParamBounce1 = 4 
dParamCFM1 = 5 
dParamStopERP1 = 6 
dParamStopCFM1 = 7 
dParamSuspensionERP1 = 8 
dParamSuspensionCFM1 = 9 
dParamERP1 = 10 
dParamGroup2 = 256 
dParamLoStop2 = 256 
dParamHiStop2 = 256 
dParamVel2 = 257 
dParamFMax2 = 258 
dParamFudgeFactor2 = 259 
dParamBounce2 = 260 
dParamCFM2 = 261 
dParamStopERP2 = 262 
dParamStopCFM2 = 263 
dParamSuspensionERP2 = 264 
dParamSuspensionCFM2 = 265 
dParamERP2 = 266 
dParamGroup3 = 512 
dParamLoStop3 = 512 
dParamHiStop3 = 512 
dParamVel3 = 513 
dParamFMax3 = 514 
dParamFudgeFactor3 = 515 
dParamBounce3 = 516 
dParamCFM3 = 517 
dParamStopERP3 = 518 
dParamStopCFM3 = 519 
dParamSuspensionERP3 = 520 
dParamSuspensionCFM3 = 521 
dParamERP3 = 522 
dParamGroup = 256 

dAMotorUser = 0 
dAMotorEuler = 1 

dInitODEFlags = { 
	"dInitFlagManualThreadCleanup" : 1, 
}

dAllocateODEDataFlags = { 
	"dAllocateFlagBasicData" : 0, 
	"dAllocateFlagCollisionData" : 1, 
	"dAllocateMaskAll" : -1, 
}

dContactMu2 = 1 
dContactFDir1 = 2 
dContactBounce = 4 
dContactSoftERP = 8 
dContactSoftCFM = 16 
dContactMotion1 = 32 
dContactMotion2 = 64 
dContactMotionN = 128 
dContactSlip1 = 256 
dContactSlip2 = 512 
dContactApprox0 = 0 
dContactApprox1_1 = 4096 
dContactApprox1_2 = 8192 
dContactApprox1 = 12288 

dMaxUserClasses = 4 

dSphereClass = 0 
dBoxClass = 0 
dCapsuleClass = 1 
dCylinderClass = 2 
dPlaneClass = 3 
dRayClass = 4 
dConvexClass = 5 
dGeomTransformClass = 6 
dTriMeshClass = 7 
dHeightfieldClass = 8 
dFirstSpaceClass = 9 
dSimpleSpaceClass = 9 
dHashSpaceClass = 9 
dSweepAndPruneSpaceClass = 10 
dQuadTreeSpaceClass = 11 
dLastSpaceClass = 11 
dFirstUserClass = 11 
dLastUserClass = 14 
dGeomNumClasses = 14 

TRIMESH_FACE_NORMALS = 0 

class __fsid_t(_rpythonic_struct_): _array_wrapper_ = True
_fsid_t = __fsid_t
class __mbstate_t(_rpythonic_struct_): pass
_mbstate_t = __mbstate_t
class __value(ctypes.Union): pass
_value = __value
class _G_fpos_t(_rpythonic_struct_): pass
G_fpos_t = _G_fpos_t
class _G_fpos64_t(_rpythonic_struct_): pass
G_fpos64_t = _G_fpos64_t
class _IO_jump_t(_rpythonic_struct_): pass
IO_jump_t = _IO_jump_t
class _IO_marker(_rpythonic_struct_): pass
IO_marker = _IO_marker
class _IO_FILE(_rpythonic_struct_): _array_wrapper_ = True
IO_FILE = _IO_FILE
class _IO_FILE_plus(_rpythonic_struct_): pass
IO_FILE_plus = _IO_FILE_plus
class wait(ctypes.Union): pass
class __wait_terminated(_rpythonic_struct_): pass
_wait_terminated = __wait_terminated
class __wait_stopped(_rpythonic_struct_): pass
_wait_stopped = __wait_stopped
class __WAIT_STATUS(ctypes.Union): pass
_WAIT_STATUS = __WAIT_STATUS
class div_t(_rpythonic_struct_): pass
class ldiv_t(_rpythonic_struct_): pass
class lldiv_t(_rpythonic_struct_): pass
class __sigset_t(_rpythonic_struct_): _array_wrapper_ = True
_sigset_t = __sigset_t
class timespec(_rpythonic_struct_): pass
class timeval(_rpythonic_struct_): pass
class fd_set(_rpythonic_struct_): _array_wrapper_ = True
class pthread_attr_t(ctypes.Union): pass
class __pthread_internal_slist(_rpythonic_struct_): pass
_pthread_internal_slist = __pthread_internal_slist
class pthread_mutex_t(ctypes.Union): pass
class __pthread_mutex_s(_rpythonic_struct_): pass
_pthread_mutex_s = __pthread_mutex_s
class pthread_mutexattr_t(ctypes.Union): pass
class pthread_cond_t(ctypes.Union): pass
class pthread_condattr_t(ctypes.Union): pass
class pthread_rwlock_t(ctypes.Union): pass
class __data(_rpythonic_struct_): pass
_data = __data
class pthread_rwlockattr_t(ctypes.Union): pass
class pthread_barrier_t(ctypes.Union): pass
class pthread_barrierattr_t(ctypes.Union): pass
class random_data(_rpythonic_struct_): pass
class drand48_data(_rpythonic_struct_): _array_wrapper_ = True
class exception(_rpythonic_struct_): pass
class __locale_struct(_rpythonic_struct_): _array_wrapper_ = True
_locale_struct = __locale_struct
class __locale_data(_rpythonic_struct_): pass
_locale_data = __locale_data
class dxWorld(_rpythonic_struct_): pass
class dxSpace(_rpythonic_struct_): pass
class dxBody(_rpythonic_struct_): pass
class dxGeom(_rpythonic_struct_): pass
class dxJoint(_rpythonic_struct_): pass
class dxJointNode(_rpythonic_struct_): pass
class dxJointGroup(_rpythonic_struct_): pass
class dJointFeedback(_rpythonic_struct_): pass
class dSurfaceParameters(_rpythonic_struct_): pass
class dContactGeom(_rpythonic_struct_): pass
class dContact(_rpythonic_struct_): pass
class dStopwatch(_rpythonic_struct_): _array_wrapper_ = True
class dMass(_rpythonic_struct_): pass
class dxTriMeshData(_rpythonic_struct_): pass
class dxHeightfieldData(_rpythonic_struct_): pass
class dGeomClass(_rpythonic_struct_): pass
## callback prototypes ##
PROTOTYPE_dGetColliderFnFn = ctypes.CFUNCTYPE(ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.POINTER(dContactGeom),ctypes.c_int,), ctypes.c_int,)
PROTOTYPE_dGetAABBFn = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),( ctypes.c_double * 6 ),)
PROTOTYPE_dAABBTestFn = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),( ctypes.c_double * 6 ),)
PROTOTYPE_dGeomDtorFn = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),)
PROTOTYPE___func = ctypes.CFUNCTYPE(ctypes.c_void_p, )
PROTOTYPE___compar_fn_t = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(ctypes.c_void_p),)
PROTOTYPE_dMessageFunction = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,)
PROTOTYPE_dAllocFunction = ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint,)
PROTOTYPE_dReallocFunction = ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,ctypes.c_uint,)
PROTOTYPE_dFreeFunction = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,)
PROTOTYPE_callback = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),)
PROTOTYPE_dNearCallback = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),)
PROTOTYPE_dTriCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,)
PROTOTYPE_dTriArrayCallback = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.POINTER(ctypes.c_int),ctypes.c_int,)
PROTOTYPE_dTriRayCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_double,ctypes.c_double,)
PROTOTYPE_dTriTriMergeCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_int,)
PROTOTYPE_dHeightfieldGetHeight = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.POINTER(ctypes.c_void_p),ctypes.c_int,ctypes.c_int,)
PROTOTYPE_dColliderFn = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.POINTER(dContactGeom),ctypes.c_int,)
## union and structures ##
__freeze_rpythonic_struct( __fsid_t, [
	( "__val", ( ctypes.c_int * 2 ) ),
])

__freeze_rpythonic_struct( __value, [
	( "__wch", ctypes.c_uint ),
	( "__wchb", ( ctypes.c_char * 4 ) ),
])

__freeze_rpythonic_struct( __mbstate_t, [
	( "__count", ctypes.c_int ),
	( "__value", __value ),
])

__freeze_rpythonic_struct( _G_fpos_t, [
	( "__pos", ctypes.c_int64 ),
	( "__state", __mbstate_t ),
])

__freeze_rpythonic_struct( _G_fpos64_t, [
	( "__pos", ctypes.c_longlong ),
	( "__state", __mbstate_t ),
])

__freeze_rpythonic_struct( _IO_jump_t, [
])

__freeze_rpythonic_struct( _IO_marker, [
	( "_next", ctypes.POINTER(_IO_marker) ),
	( "_sbuf", ctypes.POINTER(_IO_FILE) ),
	( "_pos", ctypes.c_int ),
])

__freeze_rpythonic_struct( _IO_FILE, [
	( "_flags", ctypes.c_int ),
	( "_IO_read_ptr", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_read_end", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_read_base", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_write_base", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_write_ptr", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_write_end", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_buf_base", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_buf_end", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_save_base", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_backup_base", ctypes.POINTER(ctypes.c_char) ),
	( "_IO_save_end", ctypes.POINTER(ctypes.c_char) ),
	( "_markers", ctypes.POINTER(_IO_marker) ),
	( "_chain", ctypes.POINTER(_IO_FILE) ),
	( "_fileno", ctypes.c_int ),
	( "_flags2", ctypes.c_int ),
	( "_old_offset", ctypes.c_int64 ),
	( "_cur_column", ctypes.c_ushort ),
	( "_vtable_offset", ctypes.c_char ),
	( "_shortbuf", ( ctypes.c_char * 1 ) ),
	( "_lock", ctypes.POINTER(ctypes.c_void_p) ),
	( "_offset", ctypes.c_longlong ),
	( "__pad1", ctypes.POINTER(ctypes.c_void_p) ),
	( "__pad2", ctypes.POINTER(ctypes.c_void_p) ),
	( "__pad3", ctypes.POINTER(ctypes.c_void_p) ),
	( "__pad4", ctypes.POINTER(ctypes.c_void_p) ),
	( "__pad5", ctypes.c_uint ),
	( "_mode", ctypes.c_int ),
	( "_unused2", ctypes.c_char ),
])

__freeze_rpythonic_struct( _IO_FILE_plus, [
])

__freeze_rpythonic_struct( __wait_terminated, [
	( "__w_termsig", ctypes.c_uint ),
	( "__w_coredump", ctypes.c_uint ),
	( "__w_retcode", ctypes.c_uint ),
	#opaque-warning# <rpythonic.rpythonic.SomeThing object at 0x91151cc>
])

__freeze_rpythonic_struct( __wait_stopped, [
	( "__w_stopval", ctypes.c_uint ),
	( "__w_stopsig", ctypes.c_uint ),
	#opaque-warning# <rpythonic.rpythonic.SomeThing object at 0x911530c>
])

__freeze_rpythonic_struct( wait, [
	( "w_status", ctypes.c_int ),
	( "__wait_terminated", __wait_terminated ),
	( "__wait_stopped", __wait_stopped ),
])

__freeze_rpythonic_struct( __WAIT_STATUS, [
	( "__uptr", ctypes.POINTER(wait) ),
	( "__iptr", ctypes.POINTER(ctypes.c_int) ),
])

__freeze_rpythonic_struct( div_t, [
	( "quot", ctypes.c_int ),
	( "rem", ctypes.c_int ),
])

__freeze_rpythonic_struct( ldiv_t, [
	( "quot", ctypes.c_int64 ),
	( "rem", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( lldiv_t, [
	( "quot", ctypes.c_longlong ),
	( "rem", ctypes.c_longlong ),
])

__freeze_rpythonic_struct( __sigset_t, [
	( "__val", ctypes.c_uint64 ),
])

__freeze_rpythonic_struct( timespec, [
	( "tv_sec", ctypes.c_int64 ),
	( "tv_nsec", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( timeval, [
	( "tv_sec", ctypes.c_int64 ),
	( "tv_usec", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( fd_set, [
	( "__fds_bits", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( pthread_attr_t, [
	( "__size", ( ctypes.c_char * 36 ) ),
	( "__align", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( __pthread_internal_slist, [
	( "__next", ctypes.POINTER(__pthread_internal_slist) ),
])

__freeze_rpythonic_struct( __pthread_mutex_s, [
	( "__lock", ctypes.c_int ),
	( "__count", ctypes.c_uint ),
	( "__owner", ctypes.c_int ),
	( "__kind", ctypes.c_int ),
	( "__nusers", ctypes.c_uint ),
	#opaque-warning# <rpythonic.rpythonic.SomeThing object at 0x91bcc6c>
])

__freeze_rpythonic_struct( pthread_mutex_t, [
	( "__data", __pthread_mutex_s ),
	( "__size", ( ctypes.c_char * 24 ) ),
	( "__align", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( pthread_mutexattr_t, [
	( "__size", ( ctypes.c_char * 4 ) ),
	( "__align", ctypes.c_int ),
])

__freeze_rpythonic_struct( __data, [
	( "__lock", ctypes.c_int ),
	( "__nr_readers", ctypes.c_uint ),
	( "__readers_wakeup", ctypes.c_uint ),
	( "__writer_wakeup", ctypes.c_uint ),
	( "__nr_readers_queued", ctypes.c_uint ),
	( "__nr_writers_queued", ctypes.c_uint ),
	( "__flags", ctypes.c_ubyte ),
	( "__shared", ctypes.c_ubyte ),
	( "__pad1", ctypes.c_ubyte ),
	( "__pad2", ctypes.c_ubyte ),
	( "__writer", ctypes.c_int ),
])

__freeze_rpythonic_struct( pthread_cond_t, [
	( "__data", __data ),
	( "__size", ( ctypes.c_char * 48 ) ),
	( "__align", ctypes.c_longlong ),
])

__freeze_rpythonic_struct( pthread_condattr_t, [
	( "__size", ( ctypes.c_char * 4 ) ),
	( "__align", ctypes.c_int ),
])

__freeze_rpythonic_struct( pthread_rwlock_t, [
	( "__data", __data ),
	( "__size", ( ctypes.c_char * 32 ) ),
	( "__align", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( pthread_rwlockattr_t, [
	( "__size", ( ctypes.c_char * 8 ) ),
	( "__align", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( pthread_barrier_t, [
	( "__size", ( ctypes.c_char * 20 ) ),
	( "__align", ctypes.c_int64 ),
])

__freeze_rpythonic_struct( pthread_barrierattr_t, [
	( "__size", ( ctypes.c_char * 4 ) ),
	( "__align", ctypes.c_int ),
])

__freeze_rpythonic_struct( random_data, [
	( "fptr", ctypes.POINTER(ctypes.c_int) ),
	( "rptr", ctypes.POINTER(ctypes.c_int) ),
	( "state", ctypes.POINTER(ctypes.c_int) ),
	( "rand_type", ctypes.c_int ),
	( "rand_deg", ctypes.c_int ),
	( "rand_sep", ctypes.c_int ),
	( "end_ptr", ctypes.POINTER(ctypes.c_int) ),
])

__freeze_rpythonic_struct( drand48_data, [
	( "__x", ( ctypes.c_uint16 * 3 ) ),
	( "__old_x", ( ctypes.c_uint16 * 3 ) ),
	( "__c", ctypes.c_uint16 ),
	( "__init", ctypes.c_uint16 ),
	( "__a", ctypes.c_ulonglong ),
])

__freeze_rpythonic_struct( exception, [
	( "type", ctypes.c_int ),
	( "name", ctypes.POINTER(ctypes.c_char) ),
	( "arg1", ctypes.c_double ),
	( "arg2", ctypes.c_double ),
	( "retval", ctypes.c_double ),
])

__freeze_rpythonic_struct( __locale_data, [
])

__freeze_rpythonic_struct( __locale_struct, [
	( "__locales", ctypes.POINTER(( __locale_data * 13 )) ),
	( "__ctype_b", ctypes.POINTER(ctypes.c_uint16) ),
	( "__ctype_tolower", ctypes.POINTER(ctypes.c_int) ),
	( "__ctype_toupper", ctypes.POINTER(ctypes.c_int) ),
	( "__names", ctypes.POINTER(( ctypes.c_char * 13 )) ),
])

__freeze_rpythonic_struct( dxWorld, [
])

__freeze_rpythonic_struct( dxSpace, [
])

__freeze_rpythonic_struct( dxBody, [
])

__freeze_rpythonic_struct( dxGeom, [
])

__freeze_rpythonic_struct( dxJoint, [
])

__freeze_rpythonic_struct( dxJointNode, [
])

__freeze_rpythonic_struct( dxJointGroup, [
])

__freeze_rpythonic_struct( dJointFeedback, [
	( "f1", ( ctypes.c_double * 4 ) ),
	( "t1", ( ctypes.c_double * 4 ) ),
	( "f2", ( ctypes.c_double * 4 ) ),
	( "t2", ( ctypes.c_double * 4 ) ),
])

__freeze_rpythonic_struct( dSurfaceParameters, [
	( "mode", ctypes.c_int ),
	( "mu", ctypes.c_double ),
	( "mu2", ctypes.c_double ),
	( "bounce", ctypes.c_double ),
	( "bounce_vel", ctypes.c_double ),
	( "soft_erp", ctypes.c_double ),
	( "soft_cfm", ctypes.c_double ),
	( "motion1", ctypes.c_double ),
	( "motion2", ctypes.c_double ),
	( "motionN", ctypes.c_double ),
	( "slip1", ctypes.c_double ),
	( "slip2", ctypes.c_double ),
])

__freeze_rpythonic_struct( dContactGeom, [
	( "pos", ( ctypes.c_double * 4 ) ),
	( "normal", ( ctypes.c_double * 4 ) ),
	( "depth", ctypes.c_double ),
	( "g1", ctypes.POINTER(dxGeom) ),
	( "g2", ctypes.POINTER(dxGeom) ),
	( "side1", ctypes.c_int ),
	( "side2", ctypes.c_int ),
])

__freeze_rpythonic_struct( dContact, [
	( "surface", dSurfaceParameters ),
	( "geom", dContactGeom ),
	( "fdir1", ( ctypes.c_double * 4 ) ),
])

__freeze_rpythonic_struct( dStopwatch, [
	( "time", ctypes.c_double ),
	( "cc", ( ctypes.c_ulong * 2 ) ),
])

__freeze_rpythonic_struct( dMass, [
	( "mass", ctypes.c_double ),
	( "c", ( ctypes.c_double * 4 ) ),
	( "I", ( ctypes.c_double * 12 ) ),
])

__freeze_rpythonic_struct( dxTriMeshData, [
])

__freeze_rpythonic_struct( dxHeightfieldData, [
])

__freeze_rpythonic_struct( dGeomClass, [
	( "bytes", ctypes.c_int ),
	( "collider", ctypes.POINTER(ctypes.CFUNCTYPE(ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.POINTER(dContactGeom),ctypes.c_int,), ctypes.c_int,)) ),
	( "aabb", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),( ctypes.c_double * 6 ),) ),
	( "aabb_test", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),( ctypes.c_double * 6 ),) ),
	( "dtor", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),) ),
])

## wrapper functions ##
_IO_getc = _rpythonic_function_(		"_IO_getc", ctypes.c_int, [
	("__fp",		ctypes.POINTER(_IO_FILE)),] )

_IO_putc = _rpythonic_function_(		"_IO_putc", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__fp",		ctypes.POINTER(_IO_FILE)),] )

_IO_feof = _rpythonic_function_(		"_IO_feof", ctypes.c_int, [
	("__fp",		ctypes.POINTER(_IO_FILE)),] )

_IO_ferror = _rpythonic_function_(		"_IO_ferror", ctypes.c_int, [
	("__fp",		ctypes.POINTER(_IO_FILE)),] )

_IO_peekc_locked = _rpythonic_function_(		"_IO_peekc_locked", ctypes.c_int, [
	("__fp",		ctypes.POINTER(_IO_FILE)),] )

_IO_flockfile = _rpythonic_function_(		"_IO_flockfile", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

_IO_funlockfile = _rpythonic_function_(		"_IO_funlockfile", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

_IO_ftrylockfile = _rpythonic_function_(		"_IO_ftrylockfile", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

_IO_vfscanf = _rpythonic_function_(		"_IO_vfscanf", ctypes.c_int, [
	("__restrict",		ctypes.POINTER(_IO_FILE)),
	("__restrict",		ctypes.POINTER(ctypes.c_char)),
	("none",		ctypes.c_char),
	("__restrict",		ctypes.POINTER(ctypes.c_int)),] )

_IO_vfprintf = _rpythonic_function_(		"_IO_vfprintf", ctypes.c_int, [
	("__restrict",		ctypes.POINTER(_IO_FILE)),
	("__restrict",		ctypes.POINTER(ctypes.c_char)),
	("none",		ctypes.c_char),] )

_IO_padn = _rpythonic_function_(		"_IO_padn", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.c_int),
	("none",		ctypes.c_int),] )

_IO_sgetn = _rpythonic_function_(		"_IO_sgetn", ctypes.c_uint, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.c_uint),] )

_IO_seekoff = _rpythonic_function_(		"_IO_seekoff", ctypes.c_longlong, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.c_longlong),
	("none",		ctypes.c_int),
	("none",		ctypes.c_int),] )

_IO_seekpos = _rpythonic_function_(		"_IO_seekpos", ctypes.c_longlong, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.c_longlong),
	("none",		ctypes.c_int),] )

_IO_free_backup_area = _rpythonic_function_(		"_IO_free_backup_area", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

remove = _rpythonic_function_(		"remove", ctypes.c_int, [
	("__filename",		ctypes.POINTER(ctypes.c_char)),] )

rename = _rpythonic_function_(		"rename", ctypes.c_int, [
	("__old",		ctypes.POINTER(ctypes.c_char)),
	("__new",		ctypes.POINTER(ctypes.c_char)),] )

renameat = _rpythonic_function_(		"renameat", ctypes.c_int, [
	("__oldfd",		ctypes.c_int),
	("__old",		ctypes.POINTER(ctypes.c_char)),
	("__newfd",		ctypes.c_int),
	("__new",		ctypes.POINTER(ctypes.c_char)),] )

tmpfile = _rpythonic_function_(		"tmpfile", ctypes.POINTER(_IO_FILE), [] )

tmpnam = _rpythonic_function_(		"tmpnam", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

tmpnam_r = _rpythonic_function_(		"tmpnam_r", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

tempnam = _rpythonic_function_(		"tempnam", ctypes.POINTER(ctypes.c_char), [
	("__dir",		ctypes.POINTER(ctypes.c_char)),
	("__pfx",		ctypes.POINTER(ctypes.c_char)),] )

fclose = _rpythonic_function_(		"fclose", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fflush = _rpythonic_function_(		"fflush", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fflush_unlocked = _rpythonic_function_(		"fflush_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fopen = _rpythonic_function_(		"fopen", ctypes.POINTER(_IO_FILE), [
	("__filename",		ctypes.POINTER(ctypes.c_char)),
	("__modes",		ctypes.POINTER(ctypes.c_char)),] )

freopen = _rpythonic_function_(		"freopen", ctypes.POINTER(_IO_FILE), [
	("__filename",		ctypes.POINTER(ctypes.c_char)),
	("__modes",		ctypes.POINTER(ctypes.c_char)),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fdopen = _rpythonic_function_(		"fdopen", ctypes.POINTER(_IO_FILE), [
	("__fd",		ctypes.c_int),
	("__modes",		ctypes.POINTER(ctypes.c_char)),] )

fmemopen = _rpythonic_function_(		"fmemopen", ctypes.POINTER(_IO_FILE), [
	("__s",		ctypes.POINTER(ctypes.c_void_p)),
	("__len",		ctypes.c_uint),
	("__modes",		ctypes.POINTER(ctypes.c_char)),] )

open_memstream = _rpythonic_function_(		"open_memstream", ctypes.POINTER(_IO_FILE), [
	("__bufloc",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__sizeloc",		ctypes.POINTER(ctypes.c_uint)),] )

setbuf = _rpythonic_function_(		"setbuf", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),] )

setvbuf = _rpythonic_function_(		"setvbuf", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__modes",		ctypes.c_int),
	("__n",		ctypes.c_uint),] )

setbuffer = _rpythonic_function_(		"setbuffer", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__size",		ctypes.c_uint),] )

setlinebuf = _rpythonic_function_(		"setlinebuf", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fprintf = _rpythonic_function_(		"fprintf", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

printf = _rpythonic_function_(		"printf", ctypes.c_int, [
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

sprintf = _rpythonic_function_(		"sprintf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

vfprintf = _rpythonic_function_(		"vfprintf", ctypes.c_int, [
	("__s",		ctypes.POINTER(_IO_FILE)),
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

vprintf = _rpythonic_function_(		"vprintf", ctypes.c_int, [
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

vsprintf = _rpythonic_function_(		"vsprintf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

snprintf = _rpythonic_function_(		"snprintf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__maxlen",		ctypes.c_uint),
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

vsnprintf = _rpythonic_function_(		"vsnprintf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__maxlen",		ctypes.c_uint),
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

vdprintf = _rpythonic_function_(		"vdprintf", ctypes.c_int, [
	("__fd",		ctypes.c_int),
	("__fmt",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

dprintf = _rpythonic_function_(		"dprintf", ctypes.c_int, [
	("__fd",		ctypes.c_int),
	("__fmt",		ctypes.POINTER(ctypes.c_char)),] )

fscanf = _rpythonic_function_(		"fscanf", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

scanf = _rpythonic_function_(		"scanf", ctypes.c_int, [
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

sscanf = _rpythonic_function_(		"sscanf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__format",		ctypes.POINTER(ctypes.c_char)),] )

vfscanf = _rpythonic_function_(		"vfscanf", ctypes.c_int, [
	("__s",		ctypes.POINTER(_IO_FILE)),
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

vscanf = _rpythonic_function_(		"vscanf", ctypes.c_int, [
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

vsscanf = _rpythonic_function_(		"vsscanf", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__format",		ctypes.POINTER(ctypes.c_char)),
	("__arg",		ctypes.c_char),] )

fgetc = _rpythonic_function_(		"fgetc", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

getc = _rpythonic_function_(		"getc", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

getchar = _rpythonic_function_(		"getchar", ctypes.c_int, [] )

getc_unlocked = _rpythonic_function_(		"getc_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

getchar_unlocked = _rpythonic_function_(		"getchar_unlocked", ctypes.c_int, [] )

fgetc_unlocked = _rpythonic_function_(		"fgetc_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fputc = _rpythonic_function_(		"fputc", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

putc = _rpythonic_function_(		"putc", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

putchar = _rpythonic_function_(		"putchar", ctypes.c_int, [
	("__c",		ctypes.c_int),] )

fputc_unlocked = _rpythonic_function_(		"fputc_unlocked", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

putc_unlocked = _rpythonic_function_(		"putc_unlocked", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

putchar_unlocked = _rpythonic_function_(		"putchar_unlocked", ctypes.c_int, [
	("__c",		ctypes.c_int),] )

getw = _rpythonic_function_(		"getw", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

putw = _rpythonic_function_(		"putw", ctypes.c_int, [
	("__w",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fgets = _rpythonic_function_(		"fgets", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

gets = _rpythonic_function_(		"gets", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

getdelim = _rpythonic_function_(		"getdelim", ctypes.c_int, [
	("__lineptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__n",		ctypes.POINTER(ctypes.c_uint)),
	("__delimiter",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

getline = _rpythonic_function_(		"getline", ctypes.c_int, [
	("__lineptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__n",		ctypes.POINTER(ctypes.c_uint)),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fputs = _rpythonic_function_(		"fputs", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

puts = _rpythonic_function_(		"puts", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

ungetc = _rpythonic_function_(		"ungetc", ctypes.c_int, [
	("__c",		ctypes.c_int),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fread = _rpythonic_function_(		"fread", ctypes.c_uint, [
	("__ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("__size",		ctypes.c_uint),
	("__n",		ctypes.c_uint),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fwrite = _rpythonic_function_(		"fwrite", ctypes.c_uint, [
	("__ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("__size",		ctypes.c_uint),
	("__n",		ctypes.c_uint),
	("__s",		ctypes.POINTER(_IO_FILE)),] )

fread_unlocked = _rpythonic_function_(		"fread_unlocked", ctypes.c_uint, [
	("__ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("__size",		ctypes.c_uint),
	("__n",		ctypes.c_uint),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fwrite_unlocked = _rpythonic_function_(		"fwrite_unlocked", ctypes.c_uint, [
	("__ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("__size",		ctypes.c_uint),
	("__n",		ctypes.c_uint),
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fseek = _rpythonic_function_(		"fseek", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__off",		ctypes.c_int64),
	("__whence",		ctypes.c_int),] )

ftell = _rpythonic_function_(		"ftell", ctypes.c_int64, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

rewind = _rpythonic_function_(		"rewind", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fseeko = _rpythonic_function_(		"fseeko", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__off",		ctypes.c_int64),
	("__whence",		ctypes.c_int),] )

ftello = _rpythonic_function_(		"ftello", ctypes.c_int64, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fgetpos = _rpythonic_function_(		"fgetpos", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__pos",		ctypes.POINTER(_G_fpos_t)),] )

fsetpos = _rpythonic_function_(		"fsetpos", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),
	("__pos",		ctypes.POINTER(_G_fpos_t)),] )

clearerr = _rpythonic_function_(		"clearerr", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

feof = _rpythonic_function_(		"feof", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

ferror = _rpythonic_function_(		"ferror", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

clearerr_unlocked = _rpythonic_function_(		"clearerr_unlocked", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

feof_unlocked = _rpythonic_function_(		"feof_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

ferror_unlocked = _rpythonic_function_(		"ferror_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

perror = _rpythonic_function_(		"perror", ctypes.c_void_p, [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

fileno = _rpythonic_function_(		"fileno", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

fileno_unlocked = _rpythonic_function_(		"fileno_unlocked", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

popen = _rpythonic_function_(		"popen", ctypes.POINTER(_IO_FILE), [
	("__command",		ctypes.POINTER(ctypes.c_char)),
	("__modes",		ctypes.POINTER(ctypes.c_char)),] )

pclose = _rpythonic_function_(		"pclose", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

ctermid = _rpythonic_function_(		"ctermid", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

flockfile = _rpythonic_function_(		"flockfile", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

ftrylockfile = _rpythonic_function_(		"ftrylockfile", ctypes.c_int, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

funlockfile = _rpythonic_function_(		"funlockfile", ctypes.c_void_p, [
	("__stream",		ctypes.POINTER(_IO_FILE)),] )

atof = _rpythonic_function_(		"atof", ctypes.c_double, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),] )

atoi = _rpythonic_function_(		"atoi", ctypes.c_int, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),] )

atol = _rpythonic_function_(		"atol", ctypes.c_int64, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),] )

atoll = _rpythonic_function_(		"atoll", ctypes.c_longlong, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),] )

strtod = _rpythonic_function_(		"strtod", ctypes.c_double, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),] )

strtof = _rpythonic_function_(		"strtof", ctypes.c_float, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),] )

strtold = _rpythonic_function_(		"strtold", ctypes.c_longdouble, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),] )

strtol = _rpythonic_function_(		"strtol", ctypes.c_int64, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

strtoul = _rpythonic_function_(		"strtoul", ctypes.c_uint64, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

strtoq = _rpythonic_function_(		"strtoq", ctypes.c_longlong, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

strtouq = _rpythonic_function_(		"strtouq", ctypes.c_ulonglong, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

strtoll = _rpythonic_function_(		"strtoll", ctypes.c_longlong, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

strtoull = _rpythonic_function_(		"strtoull", ctypes.c_ulonglong, [
	("__nptr",		ctypes.POINTER(ctypes.c_char)),
	("__endptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__base",		ctypes.c_int),] )

l64a = _rpythonic_function_(		"l64a", ctypes.POINTER(ctypes.c_char), [
	("__n",		ctypes.c_int64),] )

a64l = _rpythonic_function_(		"a64l", ctypes.c_int64, [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

select = _rpythonic_function_(		"select", ctypes.c_int, [
	("__nfds",		ctypes.c_int),
	("__readfds",		ctypes.POINTER(fd_set)),
	("__writefds",		ctypes.POINTER(fd_set)),
	("__exceptfds",		ctypes.POINTER(fd_set)),
	("__timeout",		ctypes.POINTER(timeval)),] )

pselect = _rpythonic_function_(		"pselect", ctypes.c_int, [
	("__nfds",		ctypes.c_int),
	("__readfds",		ctypes.POINTER(fd_set)),
	("__writefds",		ctypes.POINTER(fd_set)),
	("__exceptfds",		ctypes.POINTER(fd_set)),
	("__timeout",		ctypes.POINTER(timespec)),
	("__sigmask",		ctypes.POINTER(__sigset_t)),] )

gnu_dev_major = _rpythonic_function_(		"gnu_dev_major", ctypes.c_uint, [
	("__dev",		ctypes.c_ulonglong),] )

gnu_dev_minor = _rpythonic_function_(		"gnu_dev_minor", ctypes.c_uint, [
	("__dev",		ctypes.c_ulonglong),] )

gnu_dev_makedev = _rpythonic_function_(		"gnu_dev_makedev", ctypes.c_ulonglong, [
	("__major",		ctypes.c_uint),
	("__minor",		ctypes.c_uint),] )

random = _rpythonic_function_(		"random", ctypes.c_int64, [] )

srandom = _rpythonic_function_(		"srandom", ctypes.c_void_p, [
	("__seed",		ctypes.c_uint),] )

initstate = _rpythonic_function_(		"initstate", ctypes.POINTER(ctypes.c_char), [
	("__seed",		ctypes.c_uint),
	("__statebuf",		ctypes.POINTER(ctypes.c_char)),
	("__statelen",		ctypes.c_uint),] )

setstate = _rpythonic_function_(		"setstate", ctypes.POINTER(ctypes.c_char), [
	("__statebuf",		ctypes.POINTER(ctypes.c_char)),] )

random_r = _rpythonic_function_(		"random_r", ctypes.c_int, [
	("__buf",		ctypes.POINTER(random_data)),
	("__result",		ctypes.POINTER(ctypes.c_int)),] )

srandom_r = _rpythonic_function_(		"srandom_r", ctypes.c_int, [
	("__seed",		ctypes.c_uint),
	("__buf",		ctypes.POINTER(random_data)),] )

initstate_r = _rpythonic_function_(		"initstate_r", ctypes.c_int, [
	("__seed",		ctypes.c_uint),
	("__statebuf",		ctypes.POINTER(ctypes.c_char)),
	("__statelen",		ctypes.c_uint),
	("__buf",		ctypes.POINTER(random_data)),] )

setstate_r = _rpythonic_function_(		"setstate_r", ctypes.c_int, [
	("__statebuf",		ctypes.POINTER(ctypes.c_char)),
	("__buf",		ctypes.POINTER(random_data)),] )

rand = _rpythonic_function_(		"rand", ctypes.c_int, [] )

srand = _rpythonic_function_(		"srand", ctypes.c_void_p, [
	("__seed",		ctypes.c_uint),] )

rand_r = _rpythonic_function_(		"rand_r", ctypes.c_int, [
	("__seed",		ctypes.POINTER(ctypes.c_uint)),] )

drand48 = _rpythonic_function_(		"drand48", ctypes.c_double, [] )

erand48 = _rpythonic_function_(		"erand48", ctypes.c_double, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),] )

lrand48 = _rpythonic_function_(		"lrand48", ctypes.c_int64, [] )

nrand48 = _rpythonic_function_(		"nrand48", ctypes.c_int64, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),] )

mrand48 = _rpythonic_function_(		"mrand48", ctypes.c_int64, [] )

jrand48 = _rpythonic_function_(		"jrand48", ctypes.c_int64, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),] )

srand48 = _rpythonic_function_(		"srand48", ctypes.c_void_p, [
	("__seedval",		ctypes.c_int64),] )

seed48 = _rpythonic_function_(		"seed48", ctypes.POINTER(ctypes.c_uint16), [
	("__seed16v",		( ctypes.c_uint16 * 3 )),] )

lcong48 = _rpythonic_function_(		"lcong48", ctypes.c_void_p, [
	("__param",		( ctypes.c_uint16 * 7 )),] )

drand48_r = _rpythonic_function_(		"drand48_r", ctypes.c_int, [
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_double)),] )

erand48_r = _rpythonic_function_(		"erand48_r", ctypes.c_int, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_double)),] )

lrand48_r = _rpythonic_function_(		"lrand48_r", ctypes.c_int, [
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_int64)),] )

nrand48_r = _rpythonic_function_(		"nrand48_r", ctypes.c_int, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_int64)),] )

mrand48_r = _rpythonic_function_(		"mrand48_r", ctypes.c_int, [
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_int64)),] )

jrand48_r = _rpythonic_function_(		"jrand48_r", ctypes.c_int, [
	("__xsubi",		( ctypes.c_uint16 * 3 )),
	("__buffer",		ctypes.POINTER(drand48_data)),
	("__result",		ctypes.POINTER(ctypes.c_int64)),] )

srand48_r = _rpythonic_function_(		"srand48_r", ctypes.c_int, [
	("__seedval",		ctypes.c_int64),
	("__buffer",		ctypes.POINTER(drand48_data)),] )

seed48_r = _rpythonic_function_(		"seed48_r", ctypes.c_int, [
	("__seed16v",		( ctypes.c_uint16 * 3 )),
	("__buffer",		ctypes.POINTER(drand48_data)),] )

lcong48_r = _rpythonic_function_(		"lcong48_r", ctypes.c_int, [
	("__param",		( ctypes.c_uint16 * 7 )),
	("__buffer",		ctypes.POINTER(drand48_data)),] )

malloc = _rpythonic_function_(		"malloc", ctypes.POINTER(ctypes.c_void_p), [
	("__size",		ctypes.c_uint),] )

calloc = _rpythonic_function_(		"calloc", ctypes.POINTER(ctypes.c_void_p), [
	("__nmemb",		ctypes.c_uint),
	("__size",		ctypes.c_uint),] )

realloc = _rpythonic_function_(		"realloc", ctypes.POINTER(ctypes.c_void_p), [
	("__ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("__size",		ctypes.c_uint),] )

free = _rpythonic_function_(		"free", ctypes.c_void_p, [("__ptr",		ctypes.c_void_p)] )

cfree = _rpythonic_function_(		"cfree", ctypes.c_void_p, [("__ptr",		ctypes.c_void_p)] )

alloca = _rpythonic_function_(		"alloca", ctypes.POINTER(ctypes.c_void_p), [
	("__size",		ctypes.c_uint),] )

valloc = _rpythonic_function_(		"valloc", ctypes.POINTER(ctypes.c_void_p), [
	("__size",		ctypes.c_uint),] )

posix_memalign = _rpythonic_function_(		"posix_memalign", ctypes.c_int, [
	("__memptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_void_p))),
	("__alignment",		ctypes.c_uint),
	("__size",		ctypes.c_uint),] )

abort = _rpythonic_function_(		"abort", ctypes.c_void_p, [] )

atexit = _rpythonic_function_(		"atexit", ctypes.c_int, [
	("__func",		ctypes.c_void_p),] )

on_exit = _rpythonic_function_(		"on_exit", ctypes.c_int, [
	("__func",		ctypes.c_void_p),
	("__arg",		ctypes.POINTER(ctypes.c_void_p)),] )

exit = _rpythonic_function_(		"exit", ctypes.c_void_p, [
	("__status",		ctypes.c_int),] )

_Exit = _rpythonic_function_(		"_Exit", ctypes.c_void_p, [
	("__status",		ctypes.c_int),] )

getenv = _rpythonic_function_(		"getenv", ctypes.POINTER(ctypes.c_char), [
	("__name",		ctypes.POINTER(ctypes.c_char)),] )

putenv = _rpythonic_function_(		"putenv", ctypes.c_int, [
	("__string",		ctypes.POINTER(ctypes.c_char)),] )

setenv = _rpythonic_function_(		"setenv", ctypes.c_int, [
	("__name",		ctypes.POINTER(ctypes.c_char)),
	("__value",		ctypes.POINTER(ctypes.c_char)),
	("__replace",		ctypes.c_int),] )

unsetenv = _rpythonic_function_(		"unsetenv", ctypes.c_int, [
	("__name",		ctypes.POINTER(ctypes.c_char)),] )

clearenv = _rpythonic_function_(		"clearenv", ctypes.c_int, [] )

mktemp = _rpythonic_function_(		"mktemp", ctypes.POINTER(ctypes.c_char), [
	("__template",		ctypes.POINTER(ctypes.c_char)),] )

mkstemp = _rpythonic_function_(		"mkstemp", ctypes.c_int, [
	("__template",		ctypes.POINTER(ctypes.c_char)),] )

mkstemps = _rpythonic_function_(		"mkstemps", ctypes.c_int, [
	("__template",		ctypes.POINTER(ctypes.c_char)),
	("__suffixlen",		ctypes.c_int),] )

mkdtemp = _rpythonic_function_(		"mkdtemp", ctypes.POINTER(ctypes.c_char), [
	("__template",		ctypes.POINTER(ctypes.c_char)),] )

system = _rpythonic_function_(		"system", ctypes.c_int, [
	("__command",		ctypes.POINTER(ctypes.c_char)),] )

realpath = _rpythonic_function_(		"realpath", ctypes.POINTER(ctypes.c_char), [
	("__name",		ctypes.POINTER(ctypes.c_char)),
	("__resolved",		ctypes.POINTER(ctypes.c_char)),] )

bsearch = _rpythonic_function_(		"bsearch", ctypes.POINTER(ctypes.c_void_p), [
	("__key",		ctypes.POINTER(ctypes.c_void_p)),
	("__base",		ctypes.POINTER(ctypes.c_void_p)),
	("__nmemb",		ctypes.c_uint),
	("__size",		ctypes.c_uint),
	("__compar",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(ctypes.c_void_p),)),] )

qsort = _rpythonic_function_(		"qsort", ctypes.c_void_p, [
	("__base",		ctypes.POINTER(ctypes.c_void_p)),
	("__nmemb",		ctypes.c_uint),
	("__size",		ctypes.c_uint),
	("__compar",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(ctypes.c_void_p),)),] )

abs = _rpythonic_function_(		"abs", ctypes.c_int, [
	("__x",		ctypes.c_int),] )

div = _rpythonic_function_(		"div", ctypes.c_void_p, [
	("__numer",		ctypes.c_int),
	("__denom",		ctypes.c_int),] )

labs = _rpythonic_function_(		"labs", ctypes.c_int64, [
	("__x",		ctypes.c_int64),] )

llabs = _rpythonic_function_(		"llabs", ctypes.c_longlong, [
	("__x",		ctypes.c_longlong),] )

ldiv = _rpythonic_function_(		"ldiv", ctypes.c_void_p, [
	("__numer",		ctypes.c_int64),
	("__denom",		ctypes.c_int64),] )

lldiv = _rpythonic_function_(		"lldiv", ctypes.c_void_p, [
	("__numer",		ctypes.c_longlong),
	("__denom",		ctypes.c_longlong),] )

ecvt = _rpythonic_function_(		"ecvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_double),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),] )

fcvt = _rpythonic_function_(		"fcvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_double),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),] )

gcvt = _rpythonic_function_(		"gcvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_double),
	("__ndigit",		ctypes.c_int),
	("__buf",		ctypes.POINTER(ctypes.c_char)),] )

qecvt = _rpythonic_function_(		"qecvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_longdouble),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),] )

qfcvt = _rpythonic_function_(		"qfcvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_longdouble),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),] )

qgcvt = _rpythonic_function_(		"qgcvt", ctypes.POINTER(ctypes.c_char), [
	("__value",		ctypes.c_longdouble),
	("__ndigit",		ctypes.c_int),
	("__buf",		ctypes.POINTER(ctypes.c_char)),] )

ecvt_r = _rpythonic_function_(		"ecvt_r", ctypes.c_int, [
	("__value",		ctypes.c_double),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__len",		ctypes.c_uint),] )

fcvt_r = _rpythonic_function_(		"fcvt_r", ctypes.c_int, [
	("__value",		ctypes.c_double),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__len",		ctypes.c_uint),] )

qecvt_r = _rpythonic_function_(		"qecvt_r", ctypes.c_int, [
	("__value",		ctypes.c_longdouble),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__len",		ctypes.c_uint),] )

qfcvt_r = _rpythonic_function_(		"qfcvt_r", ctypes.c_int, [
	("__value",		ctypes.c_longdouble),
	("__ndigit",		ctypes.c_int),
	("__decpt",		ctypes.POINTER(ctypes.c_int)),
	("__sign",		ctypes.POINTER(ctypes.c_int)),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__len",		ctypes.c_uint),] )

mblen = _rpythonic_function_(		"mblen", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

mbtowc = _rpythonic_function_(		"mbtowc", ctypes.c_int, [
	("__pwc",		ctypes.POINTER(ctypes.c_int)),
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

wctomb = _rpythonic_function_(		"wctomb", ctypes.c_int, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__wchar",		ctypes.c_int),] )

mbstowcs = _rpythonic_function_(		"mbstowcs", ctypes.c_uint, [
	("__pwcs",		ctypes.POINTER(ctypes.c_int)),
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

wcstombs = _rpythonic_function_(		"wcstombs", ctypes.c_uint, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__pwcs",		ctypes.POINTER(ctypes.c_int)),
	("__n",		ctypes.c_uint),] )

rpmatch = _rpythonic_function_(		"rpmatch", ctypes.c_int, [
	("__response",		ctypes.POINTER(ctypes.c_char)),] )

getsubopt = _rpythonic_function_(		"getsubopt", ctypes.c_int, [
	("__optionp",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__tokens",		ctypes.POINTER(ctypes.c_char)),
	("__valuep",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),] )

getloadavg = _rpythonic_function_(		"getloadavg", ctypes.c_int, [
	("__loadavg",		ctypes.c_double),
	("__nelem",		ctypes.c_int),] )

acos = _rpythonic_function_(		"acos", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

asin = _rpythonic_function_(		"asin", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

atan = _rpythonic_function_(		"atan", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

atan2 = _rpythonic_function_(		"atan2", ctypes.c_double, [
	("__y",		ctypes.c_double),
	("__x",		ctypes.c_double),] )

cos = _rpythonic_function_(		"cos", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

sin = _rpythonic_function_(		"sin", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

tan = _rpythonic_function_(		"tan", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

cosh = _rpythonic_function_(		"cosh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

sinh = _rpythonic_function_(		"sinh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

tanh = _rpythonic_function_(		"tanh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

acosh = _rpythonic_function_(		"acosh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

asinh = _rpythonic_function_(		"asinh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

atanh = _rpythonic_function_(		"atanh", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

exp = _rpythonic_function_(		"exp", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

frexp = _rpythonic_function_(		"frexp", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__exponent",		ctypes.POINTER(ctypes.c_int)),] )

ldexp = _rpythonic_function_(		"ldexp", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__exponent",		ctypes.c_int),] )

log = _rpythonic_function_(		"log", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

log10 = _rpythonic_function_(		"log10", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

modf = _rpythonic_function_(		"modf", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__iptr",		ctypes.POINTER(ctypes.c_double)),] )

expm1 = _rpythonic_function_(		"expm1", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

log1p = _rpythonic_function_(		"log1p", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

logb = _rpythonic_function_(		"logb", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

exp2 = _rpythonic_function_(		"exp2", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

log2 = _rpythonic_function_(		"log2", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

pow = _rpythonic_function_(		"pow", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

sqrt = _rpythonic_function_(		"sqrt", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

hypot = _rpythonic_function_(		"hypot", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

cbrt = _rpythonic_function_(		"cbrt", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

ceil = _rpythonic_function_(		"ceil", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

fabs = _rpythonic_function_(		"fabs", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

floor = _rpythonic_function_(		"floor", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

fmod = _rpythonic_function_(		"fmod", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

isinf = _rpythonic_function_(		"isinf", ctypes.c_int, [
	("__value",		ctypes.c_double),] )

finite = _rpythonic_function_(		"finite", ctypes.c_int, [
	("__value",		ctypes.c_double),] )

drem = _rpythonic_function_(		"drem", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

significand = _rpythonic_function_(		"significand", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

copysign = _rpythonic_function_(		"copysign", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

nan = _rpythonic_function_(		"nan", ctypes.c_double, [
	("__tagb",		ctypes.POINTER(ctypes.c_char)),] )

isnan = _rpythonic_function_(		"isnan", ctypes.c_int, [
	("__value",		ctypes.c_double),] )

j0 = _rpythonic_function_(		"j0", ctypes.c_double, [
	("none",		ctypes.c_double),] )

j1 = _rpythonic_function_(		"j1", ctypes.c_double, [
	("none",		ctypes.c_double),] )

jn = _rpythonic_function_(		"jn", ctypes.c_double, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_double),] )

y0 = _rpythonic_function_(		"y0", ctypes.c_double, [
	("none",		ctypes.c_double),] )

y1 = _rpythonic_function_(		"y1", ctypes.c_double, [
	("none",		ctypes.c_double),] )

yn = _rpythonic_function_(		"yn", ctypes.c_double, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_double),] )

erf = _rpythonic_function_(		"erf", ctypes.c_double, [
	("none",		ctypes.c_double),] )

erfc = _rpythonic_function_(		"erfc", ctypes.c_double, [
	("none",		ctypes.c_double),] )

lgamma = _rpythonic_function_(		"lgamma", ctypes.c_double, [
	("none",		ctypes.c_double),] )

tgamma = _rpythonic_function_(		"tgamma", ctypes.c_double, [
	("none",		ctypes.c_double),] )

gamma = _rpythonic_function_(		"gamma", ctypes.c_double, [
	("none",		ctypes.c_double),] )

lgamma_r = _rpythonic_function_(		"lgamma_r", ctypes.c_double, [
	("none",		ctypes.c_double),
	("__signgamp",		ctypes.POINTER(ctypes.c_int)),] )

rint = _rpythonic_function_(		"rint", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

nextafter = _rpythonic_function_(		"nextafter", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

nexttoward = _rpythonic_function_(		"nexttoward", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_longdouble),] )

remainder = _rpythonic_function_(		"remainder", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

scalbn = _rpythonic_function_(		"scalbn", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__n",		ctypes.c_int),] )

ilogb = _rpythonic_function_(		"ilogb", ctypes.c_int, [
	("__x",		ctypes.c_double),] )

scalbln = _rpythonic_function_(		"scalbln", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__n",		ctypes.c_int64),] )

nearbyint = _rpythonic_function_(		"nearbyint", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

round = _rpythonic_function_(		"round", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

trunc = _rpythonic_function_(		"trunc", ctypes.c_double, [
	("__x",		ctypes.c_double),] )

remquo = _rpythonic_function_(		"remquo", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),
	("__quo",		ctypes.POINTER(ctypes.c_int)),] )

lrint = _rpythonic_function_(		"lrint", ctypes.c_int64, [
	("__x",		ctypes.c_double),] )

llrint = _rpythonic_function_(		"llrint", ctypes.c_longlong, [
	("__x",		ctypes.c_double),] )

lround = _rpythonic_function_(		"lround", ctypes.c_int64, [
	("__x",		ctypes.c_double),] )

llround = _rpythonic_function_(		"llround", ctypes.c_longlong, [
	("__x",		ctypes.c_double),] )

fdim = _rpythonic_function_(		"fdim", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

fmax = _rpythonic_function_(		"fmax", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

fmin = _rpythonic_function_(		"fmin", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),] )

fma = _rpythonic_function_(		"fma", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__y",		ctypes.c_double),
	("__z",		ctypes.c_double),] )

scalb = _rpythonic_function_(		"scalb", ctypes.c_double, [
	("__x",		ctypes.c_double),
	("__n",		ctypes.c_double),] )

acosf = _rpythonic_function_(		"acosf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

asinf = _rpythonic_function_(		"asinf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

atanf = _rpythonic_function_(		"atanf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

atan2f = _rpythonic_function_(		"atan2f", ctypes.c_float, [
	("__y",		ctypes.c_float),
	("__x",		ctypes.c_float),] )

cosf = _rpythonic_function_(		"cosf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

sinf = _rpythonic_function_(		"sinf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

tanf = _rpythonic_function_(		"tanf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

coshf = _rpythonic_function_(		"coshf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

sinhf = _rpythonic_function_(		"sinhf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

tanhf = _rpythonic_function_(		"tanhf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

acoshf = _rpythonic_function_(		"acoshf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

asinhf = _rpythonic_function_(		"asinhf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

atanhf = _rpythonic_function_(		"atanhf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

expf = _rpythonic_function_(		"expf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

frexpf = _rpythonic_function_(		"frexpf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__exponent",		ctypes.POINTER(ctypes.c_int)),] )

ldexpf = _rpythonic_function_(		"ldexpf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__exponent",		ctypes.c_int),] )

logf = _rpythonic_function_(		"logf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

log10f = _rpythonic_function_(		"log10f", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

modff = _rpythonic_function_(		"modff", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__iptr",		ctypes.POINTER(ctypes.c_float)),] )

expm1f = _rpythonic_function_(		"expm1f", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

log1pf = _rpythonic_function_(		"log1pf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

logbf = _rpythonic_function_(		"logbf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

exp2f = _rpythonic_function_(		"exp2f", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

log2f = _rpythonic_function_(		"log2f", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

powf = _rpythonic_function_(		"powf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

sqrtf = _rpythonic_function_(		"sqrtf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

hypotf = _rpythonic_function_(		"hypotf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

cbrtf = _rpythonic_function_(		"cbrtf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

ceilf = _rpythonic_function_(		"ceilf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

fabsf = _rpythonic_function_(		"fabsf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

floorf = _rpythonic_function_(		"floorf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

fmodf = _rpythonic_function_(		"fmodf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

isinff = _rpythonic_function_(		"isinff", ctypes.c_int, [
	("__value",		ctypes.c_float),] )

finitef = _rpythonic_function_(		"finitef", ctypes.c_int, [
	("__value",		ctypes.c_float),] )

dremf = _rpythonic_function_(		"dremf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

significandf = _rpythonic_function_(		"significandf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

copysignf = _rpythonic_function_(		"copysignf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

nanf = _rpythonic_function_(		"nanf", ctypes.c_float, [
	("__tagb",		ctypes.POINTER(ctypes.c_char)),] )

isnanf = _rpythonic_function_(		"isnanf", ctypes.c_int, [
	("__value",		ctypes.c_float),] )

j0f = _rpythonic_function_(		"j0f", ctypes.c_float, [
	("none",		ctypes.c_float),] )

j1f = _rpythonic_function_(		"j1f", ctypes.c_float, [
	("none",		ctypes.c_float),] )

jnf = _rpythonic_function_(		"jnf", ctypes.c_float, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_float),] )

y0f = _rpythonic_function_(		"y0f", ctypes.c_float, [
	("none",		ctypes.c_float),] )

y1f = _rpythonic_function_(		"y1f", ctypes.c_float, [
	("none",		ctypes.c_float),] )

ynf = _rpythonic_function_(		"ynf", ctypes.c_float, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_float),] )

erff = _rpythonic_function_(		"erff", ctypes.c_float, [
	("none",		ctypes.c_float),] )

erfcf = _rpythonic_function_(		"erfcf", ctypes.c_float, [
	("none",		ctypes.c_float),] )

lgammaf = _rpythonic_function_(		"lgammaf", ctypes.c_float, [
	("none",		ctypes.c_float),] )

tgammaf = _rpythonic_function_(		"tgammaf", ctypes.c_float, [
	("none",		ctypes.c_float),] )

gammaf = _rpythonic_function_(		"gammaf", ctypes.c_float, [
	("none",		ctypes.c_float),] )

lgammaf_r = _rpythonic_function_(		"lgammaf_r", ctypes.c_float, [
	("none",		ctypes.c_float),
	("__signgamp",		ctypes.POINTER(ctypes.c_int)),] )

rintf = _rpythonic_function_(		"rintf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

nextafterf = _rpythonic_function_(		"nextafterf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

nexttowardf = _rpythonic_function_(		"nexttowardf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_longdouble),] )

remainderf = _rpythonic_function_(		"remainderf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

scalbnf = _rpythonic_function_(		"scalbnf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__n",		ctypes.c_int),] )

ilogbf = _rpythonic_function_(		"ilogbf", ctypes.c_int, [
	("__x",		ctypes.c_float),] )

scalblnf = _rpythonic_function_(		"scalblnf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__n",		ctypes.c_int64),] )

nearbyintf = _rpythonic_function_(		"nearbyintf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

roundf = _rpythonic_function_(		"roundf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

truncf = _rpythonic_function_(		"truncf", ctypes.c_float, [
	("__x",		ctypes.c_float),] )

remquof = _rpythonic_function_(		"remquof", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),
	("__quo",		ctypes.POINTER(ctypes.c_int)),] )

lrintf = _rpythonic_function_(		"lrintf", ctypes.c_int64, [
	("__x",		ctypes.c_float),] )

llrintf = _rpythonic_function_(		"llrintf", ctypes.c_longlong, [
	("__x",		ctypes.c_float),] )

lroundf = _rpythonic_function_(		"lroundf", ctypes.c_int64, [
	("__x",		ctypes.c_float),] )

llroundf = _rpythonic_function_(		"llroundf", ctypes.c_longlong, [
	("__x",		ctypes.c_float),] )

fdimf = _rpythonic_function_(		"fdimf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

fmaxf = _rpythonic_function_(		"fmaxf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

fminf = _rpythonic_function_(		"fminf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),] )

fmaf = _rpythonic_function_(		"fmaf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__y",		ctypes.c_float),
	("__z",		ctypes.c_float),] )

scalbf = _rpythonic_function_(		"scalbf", ctypes.c_float, [
	("__x",		ctypes.c_float),
	("__n",		ctypes.c_float),] )

acosl = _rpythonic_function_(		"acosl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

asinl = _rpythonic_function_(		"asinl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

atanl = _rpythonic_function_(		"atanl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

atan2l = _rpythonic_function_(		"atan2l", ctypes.c_longdouble, [
	("__y",		ctypes.c_longdouble),
	("__x",		ctypes.c_longdouble),] )

cosl = _rpythonic_function_(		"cosl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

sinl = _rpythonic_function_(		"sinl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

tanl = _rpythonic_function_(		"tanl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

coshl = _rpythonic_function_(		"coshl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

sinhl = _rpythonic_function_(		"sinhl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

tanhl = _rpythonic_function_(		"tanhl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

acoshl = _rpythonic_function_(		"acoshl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

asinhl = _rpythonic_function_(		"asinhl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

atanhl = _rpythonic_function_(		"atanhl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

expl = _rpythonic_function_(		"expl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

frexpl = _rpythonic_function_(		"frexpl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__exponent",		ctypes.POINTER(ctypes.c_int)),] )

ldexpl = _rpythonic_function_(		"ldexpl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__exponent",		ctypes.c_int),] )

logl = _rpythonic_function_(		"logl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

log10l = _rpythonic_function_(		"log10l", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

modfl = _rpythonic_function_(		"modfl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__iptr",		ctypes.POINTER(ctypes.c_longdouble)),] )

expm1l = _rpythonic_function_(		"expm1l", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

log1pl = _rpythonic_function_(		"log1pl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

logbl = _rpythonic_function_(		"logbl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

exp2l = _rpythonic_function_(		"exp2l", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

log2l = _rpythonic_function_(		"log2l", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

powl = _rpythonic_function_(		"powl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

sqrtl = _rpythonic_function_(		"sqrtl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

hypotl = _rpythonic_function_(		"hypotl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

cbrtl = _rpythonic_function_(		"cbrtl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

ceill = _rpythonic_function_(		"ceill", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

fabsl = _rpythonic_function_(		"fabsl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

floorl = _rpythonic_function_(		"floorl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

fmodl = _rpythonic_function_(		"fmodl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

isinfl = _rpythonic_function_(		"isinfl", ctypes.c_int, [
	("__value",		ctypes.c_longdouble),] )

finitel = _rpythonic_function_(		"finitel", ctypes.c_int, [
	("__value",		ctypes.c_longdouble),] )

dreml = _rpythonic_function_(		"dreml", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

significandl = _rpythonic_function_(		"significandl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

copysignl = _rpythonic_function_(		"copysignl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

nanl = _rpythonic_function_(		"nanl", ctypes.c_longdouble, [
	("__tagb",		ctypes.POINTER(ctypes.c_char)),] )

isnanl = _rpythonic_function_(		"isnanl", ctypes.c_int, [
	("__value",		ctypes.c_longdouble),] )

j0l = _rpythonic_function_(		"j0l", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

j1l = _rpythonic_function_(		"j1l", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

jnl = _rpythonic_function_(		"jnl", ctypes.c_longdouble, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_longdouble),] )

y0l = _rpythonic_function_(		"y0l", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

y1l = _rpythonic_function_(		"y1l", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

ynl = _rpythonic_function_(		"ynl", ctypes.c_longdouble, [
	("none",		ctypes.c_int),
	("none",		ctypes.c_longdouble),] )

erfl = _rpythonic_function_(		"erfl", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

erfcl = _rpythonic_function_(		"erfcl", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

lgammal = _rpythonic_function_(		"lgammal", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

tgammal = _rpythonic_function_(		"tgammal", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

gammal = _rpythonic_function_(		"gammal", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),] )

lgammal_r = _rpythonic_function_(		"lgammal_r", ctypes.c_longdouble, [
	("none",		ctypes.c_longdouble),
	("__signgamp",		ctypes.POINTER(ctypes.c_int)),] )

rintl = _rpythonic_function_(		"rintl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

nextafterl = _rpythonic_function_(		"nextafterl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

nexttowardl = _rpythonic_function_(		"nexttowardl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

remainderl = _rpythonic_function_(		"remainderl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

scalbnl = _rpythonic_function_(		"scalbnl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__n",		ctypes.c_int),] )

ilogbl = _rpythonic_function_(		"ilogbl", ctypes.c_int, [
	("__x",		ctypes.c_longdouble),] )

scalblnl = _rpythonic_function_(		"scalblnl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__n",		ctypes.c_int64),] )

nearbyintl = _rpythonic_function_(		"nearbyintl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

roundl = _rpythonic_function_(		"roundl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

truncl = _rpythonic_function_(		"truncl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),] )

remquol = _rpythonic_function_(		"remquol", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),
	("__quo",		ctypes.POINTER(ctypes.c_int)),] )

lrintl = _rpythonic_function_(		"lrintl", ctypes.c_int64, [
	("__x",		ctypes.c_longdouble),] )

llrintl = _rpythonic_function_(		"llrintl", ctypes.c_longlong, [
	("__x",		ctypes.c_longdouble),] )

lroundl = _rpythonic_function_(		"lroundl", ctypes.c_int64, [
	("__x",		ctypes.c_longdouble),] )

llroundl = _rpythonic_function_(		"llroundl", ctypes.c_longlong, [
	("__x",		ctypes.c_longdouble),] )

fdiml = _rpythonic_function_(		"fdiml", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

fmaxl = _rpythonic_function_(		"fmaxl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

fminl = _rpythonic_function_(		"fminl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),] )

fmal = _rpythonic_function_(		"fmal", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__y",		ctypes.c_longdouble),
	("__z",		ctypes.c_longdouble),] )

scalbl = _rpythonic_function_(		"scalbl", ctypes.c_longdouble, [
	("__x",		ctypes.c_longdouble),
	("__n",		ctypes.c_longdouble),] )

matherr = _rpythonic_function_(		"matherr", ctypes.c_int, [
	("__exc",		ctypes.POINTER(exception)),] )

memcpy = _rpythonic_function_(		"memcpy", ctypes.POINTER(ctypes.c_void_p), [
	("__dest",		ctypes.POINTER(ctypes.c_void_p)),
	("__src",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

memmove = _rpythonic_function_(		"memmove", ctypes.POINTER(ctypes.c_void_p), [
	("__dest",		ctypes.POINTER(ctypes.c_void_p)),
	("__src",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

memccpy = _rpythonic_function_(		"memccpy", ctypes.POINTER(ctypes.c_void_p), [
	("__dest",		ctypes.POINTER(ctypes.c_void_p)),
	("__src",		ctypes.POINTER(ctypes.c_void_p)),
	("__c",		ctypes.c_int),
	("__n",		ctypes.c_uint),] )

memset = _rpythonic_function_(		"memset", ctypes.POINTER(ctypes.c_void_p), [
	("__s",		ctypes.POINTER(ctypes.c_void_p)),
	("__c",		ctypes.c_int),
	("__n",		ctypes.c_uint),] )

memcmp = _rpythonic_function_(		"memcmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_void_p)),
	("__s2",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

memchr = _rpythonic_function_(		"memchr", ctypes.POINTER(ctypes.c_void_p), [
	("__s",		ctypes.POINTER(ctypes.c_void_p)),
	("__c",		ctypes.c_int),
	("__n",		ctypes.c_uint),] )

strcpy = _rpythonic_function_(		"strcpy", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),] )

strncpy = _rpythonic_function_(		"strncpy", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strcat = _rpythonic_function_(		"strcat", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),] )

strncat = _rpythonic_function_(		"strncat", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strcmp = _rpythonic_function_(		"strcmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),] )

strncmp = _rpythonic_function_(		"strncmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strcoll = _rpythonic_function_(		"strcoll", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),] )

strxfrm = _rpythonic_function_(		"strxfrm", ctypes.c_uint, [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strcoll_l = _rpythonic_function_(		"strcoll_l", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),
	("__l",		ctypes.POINTER(__locale_struct)),] )

strxfrm_l = _rpythonic_function_(		"strxfrm_l", ctypes.c_uint, [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),
	("__l",		ctypes.POINTER(__locale_struct)),] )

strdup = _rpythonic_function_(		"strdup", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

strndup = _rpythonic_function_(		"strndup", ctypes.POINTER(ctypes.c_char), [
	("__string",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strchr = _rpythonic_function_(		"strchr", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__c",		ctypes.c_int),] )

strrchr = _rpythonic_function_(		"strrchr", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__c",		ctypes.c_int),] )

strcspn = _rpythonic_function_(		"strcspn", ctypes.c_uint, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__reject",		ctypes.POINTER(ctypes.c_char)),] )

strspn = _rpythonic_function_(		"strspn", ctypes.c_uint, [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__accept",		ctypes.POINTER(ctypes.c_char)),] )

strpbrk = _rpythonic_function_(		"strpbrk", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__accept",		ctypes.POINTER(ctypes.c_char)),] )

strstr = _rpythonic_function_(		"strstr", ctypes.POINTER(ctypes.c_char), [
	("__haystack",		ctypes.POINTER(ctypes.c_char)),
	("__needle",		ctypes.POINTER(ctypes.c_char)),] )

strtok = _rpythonic_function_(		"strtok", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__delim",		ctypes.POINTER(ctypes.c_char)),] )

strtok_r = _rpythonic_function_(		"strtok_r", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__delim",		ctypes.POINTER(ctypes.c_char)),
	("__save_ptr",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),] )

strlen = _rpythonic_function_(		"strlen", ctypes.c_uint, [
	("__s",		ctypes.POINTER(ctypes.c_char)),] )

strnlen = _rpythonic_function_(		"strnlen", ctypes.c_uint, [
	("__string",		ctypes.POINTER(ctypes.c_char)),
	("__maxlen",		ctypes.c_uint),] )

strerror = _rpythonic_function_(		"strerror", ctypes.POINTER(ctypes.c_char), [
	("__errnum",		ctypes.c_int),] )

strerror_r = _rpythonic_function_(		"strerror_r", ctypes.c_int, [
	("__errnum",		ctypes.c_int),
	("__buf",		ctypes.POINTER(ctypes.c_char)),
	("__buflen",		ctypes.c_uint),] )

strerror_l = _rpythonic_function_(		"strerror_l", ctypes.POINTER(ctypes.c_char), [
	("__errnum",		ctypes.c_int),
	("__l",		ctypes.POINTER(__locale_struct)),] )

bcopy = _rpythonic_function_(		"bcopy", ctypes.c_void_p, [
	("__src",		ctypes.POINTER(ctypes.c_void_p)),
	("__dest",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

bzero = _rpythonic_function_(		"bzero", ctypes.c_void_p, [
	("__s",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

bcmp = _rpythonic_function_(		"bcmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_void_p)),
	("__s2",		ctypes.POINTER(ctypes.c_void_p)),
	("__n",		ctypes.c_uint),] )

index = _rpythonic_function_(		"index", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__c",		ctypes.c_int),] )

rindex = _rpythonic_function_(		"rindex", ctypes.POINTER(ctypes.c_char), [
	("__s",		ctypes.POINTER(ctypes.c_char)),
	("__c",		ctypes.c_int),] )

ffs = _rpythonic_function_(		"ffs", ctypes.c_int, [
	("__i",		ctypes.c_int),] )

strcasecmp = _rpythonic_function_(		"strcasecmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),] )

strncasecmp = _rpythonic_function_(		"strncasecmp", ctypes.c_int, [
	("__s1",		ctypes.POINTER(ctypes.c_char)),
	("__s2",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

strsep = _rpythonic_function_(		"strsep", ctypes.POINTER(ctypes.c_char), [
	("__stringp",		ctypes.POINTER(ctypes.POINTER(ctypes.c_char))),
	("__delim",		ctypes.POINTER(ctypes.c_char)),] )

strsignal = _rpythonic_function_(		"strsignal", ctypes.POINTER(ctypes.c_char), [
	("__sig",		ctypes.c_int),] )

stpcpy = _rpythonic_function_(		"stpcpy", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),] )

stpncpy = _rpythonic_function_(		"stpncpy", ctypes.POINTER(ctypes.c_char), [
	("__dest",		ctypes.POINTER(ctypes.c_char)),
	("__src",		ctypes.POINTER(ctypes.c_char)),
	("__n",		ctypes.c_uint),] )

dMessageFunction = _rpythonic_function_(		"dMessageFunction", ctypes.c_void_p, [
	("errnum",		ctypes.c_int),
	("msg",		ctypes.POINTER(ctypes.c_char)),
	("ap",		ctypes.c_char),] )

dSetErrorHandler = _rpythonic_function_(		"dSetErrorHandler", ctypes.c_void_p, [
	("fn",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,)),] )

dSetDebugHandler = _rpythonic_function_(		"dSetDebugHandler", ctypes.c_void_p, [
	("fn",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,)),] )

dSetMessageHandler = _rpythonic_function_(		"dSetMessageHandler", ctypes.c_void_p, [
	("fn",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,)),] )

dGetErrorHandler = _rpythonic_function_(		"dGetErrorHandler", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,), [] )

dGetDebugHandler = _rpythonic_function_(		"dGetDebugHandler", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,), [] )

dGetMessageHandler = _rpythonic_function_(		"dGetMessageHandler", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int,ctypes.POINTER(ctypes.c_char),ctypes.c_char,), [] )

dError = _rpythonic_function_(		"dError", ctypes.c_void_p, [
	("num",		ctypes.c_int),
	("msg",		ctypes.POINTER(ctypes.c_char)),] )

dDebug = _rpythonic_function_(		"dDebug", ctypes.c_void_p, [
	("num",		ctypes.c_int),
	("msg",		ctypes.POINTER(ctypes.c_char)),] )

dMessage = _rpythonic_function_(		"dMessage", ctypes.c_void_p, [
	("num",		ctypes.c_int),
	("msg",		ctypes.POINTER(ctypes.c_char)),] )

dGeomMoved = _rpythonic_function_(		"dGeomMoved", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomGetBodyNext = _rpythonic_function_(		"dGeomGetBodyNext", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dGetConfiguration = _rpythonic_function_(		"dGetConfiguration", ctypes.POINTER(ctypes.c_char), [] )

dCheckConfiguration = _rpythonic_function_(		"dCheckConfiguration", ctypes.c_int, [
	("token",		ctypes.POINTER(ctypes.c_char)),] )

dInitODE = _rpythonic_function_(		"dInitODE", ctypes.c_void_p, [] )

dInitODE2 = _rpythonic_function_(		"dInitODE2", ctypes.c_int, [
	("uiInitFlags",		ctypes.c_uint),] )

dAllocateODEDataForThread = _rpythonic_function_(		"dAllocateODEDataForThread", ctypes.c_int, [
	("uiAllocateFlags",		ctypes.c_uint),] )

dCleanupODEAllDataForThread = _rpythonic_function_(		"dCleanupODEAllDataForThread", ctypes.c_void_p, [] )

dCloseODE = _rpythonic_function_(		"dCloseODE", ctypes.c_void_p, [] )

dAllocFunction = _rpythonic_function_(		"dAllocFunction", ctypes.POINTER(ctypes.c_void_p), [
	("size",		ctypes.c_uint),] )

dReallocFunction = _rpythonic_function_(		"dReallocFunction", ctypes.POINTER(ctypes.c_void_p), [
	("ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("oldsize",		ctypes.c_uint),
	("newsize",		ctypes.c_uint),] )

dFreeFunction = _rpythonic_function_(		"dFreeFunction", ctypes.c_void_p, [
	("ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("size",		ctypes.c_uint),] )

dSetAllocHandler = _rpythonic_function_(		"dSetAllocHandler", ctypes.c_void_p, [
	("fn",		ctypes.POINTER(ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint,))),] )

dSetReallocHandler = _rpythonic_function_(		"dSetReallocHandler", ctypes.c_void_p, [
	("fn",		ctypes.POINTER(ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,ctypes.c_uint,))),] )

dSetFreeHandler = _rpythonic_function_(		"dSetFreeHandler", ctypes.c_void_p, [
	("fn",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,)),] )

dGetAllocHandler = _rpythonic_function_(		"dGetAllocHandler", ctypes.POINTER(ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint,)), [] )

dGetReallocHandler = _rpythonic_function_(		"dGetReallocHandler", ctypes.POINTER(ctypes.CFUNCTYPE(ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,ctypes.c_uint,)), [] )

dGetFreeHandler = _rpythonic_function_(		"dGetFreeHandler", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.c_uint,), [] )

dAlloc = _rpythonic_function_(		"dAlloc", ctypes.POINTER(ctypes.c_void_p), [
	("size",		ctypes.c_uint),] )

dRealloc = _rpythonic_function_(		"dRealloc", ctypes.POINTER(ctypes.c_void_p), [
	("ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("oldsize",		ctypes.c_uint),
	("newsize",		ctypes.c_uint),] )

dFree = _rpythonic_function_(		"dFree", ctypes.c_void_p, [
	("ptr",		ctypes.POINTER(ctypes.c_void_p)),
	("size",		ctypes.c_uint),] )

_dSafeNormalize3 = _rpythonic_function_(		"_dSafeNormalize3", ctypes.c_int, [
	("a",		( ctypes.c_double * 4 )),] )

_dSafeNormalize4 = _rpythonic_function_(		"_dSafeNormalize4", ctypes.c_int, [
	("a",		( ctypes.c_double * 4 )),] )

dSafeNormalize3 = _rpythonic_function_(		"dSafeNormalize3", ctypes.c_int, [
	("a",		( ctypes.c_double * 4 )),] )

dSafeNormalize4 = _rpythonic_function_(		"dSafeNormalize4", ctypes.c_int, [
	("a",		( ctypes.c_double * 4 )),] )

dNormalize3 = _rpythonic_function_(		"dNormalize3", ctypes.c_void_p, [
	("a",		( ctypes.c_double * 4 )),] )

dNormalize4 = _rpythonic_function_(		"dNormalize4", ctypes.c_void_p, [
	("a",		( ctypes.c_double * 4 )),] )

dPlaneSpace = _rpythonic_function_(		"dPlaneSpace", ctypes.c_void_p, [
	("n",		( ctypes.c_double * 4 )),
	("p",		( ctypes.c_double * 4 )),
	("q",		( ctypes.c_double * 4 )),] )

dOrthogonalizeR = _rpythonic_function_(		"dOrthogonalizeR", ctypes.c_void_p, [
	("m",		( ctypes.c_double * 12 )),] )

dSetZero = _rpythonic_function_(		"dSetZero", ctypes.c_void_p, [
	("a",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dSetValue = _rpythonic_function_(		"dSetValue", ctypes.c_void_p, [
	("a",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dDot = _rpythonic_function_(		"dDot", ctypes.c_double, [
	("a",		ctypes.POINTER(ctypes.c_double)),
	("b",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dMultiply0 = _rpythonic_function_(		"dMultiply0", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("B",		ctypes.POINTER(ctypes.c_double)),
	("C",		ctypes.POINTER(ctypes.c_double)),
	("p",		ctypes.c_int),
	("q",		ctypes.c_int),
	("r",		ctypes.c_int),] )

dMultiply1 = _rpythonic_function_(		"dMultiply1", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("B",		ctypes.POINTER(ctypes.c_double)),
	("C",		ctypes.POINTER(ctypes.c_double)),
	("p",		ctypes.c_int),
	("q",		ctypes.c_int),
	("r",		ctypes.c_int),] )

dMultiply2 = _rpythonic_function_(		"dMultiply2", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("B",		ctypes.POINTER(ctypes.c_double)),
	("C",		ctypes.POINTER(ctypes.c_double)),
	("p",		ctypes.c_int),
	("q",		ctypes.c_int),
	("r",		ctypes.c_int),] )

dFactorCholesky = _rpythonic_function_(		"dFactorCholesky", ctypes.c_int, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dSolveCholesky = _rpythonic_function_(		"dSolveCholesky", ctypes.c_void_p, [
	("L",		ctypes.POINTER(ctypes.c_double)),
	("b",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dInvertPDMatrix = _rpythonic_function_(		"dInvertPDMatrix", ctypes.c_int, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("Ainv",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dIsPositiveDefinite = _rpythonic_function_(		"dIsPositiveDefinite", ctypes.c_int, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dFactorLDLT = _rpythonic_function_(		"dFactorLDLT", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("d",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dSolveL1 = _rpythonic_function_(		"dSolveL1", ctypes.c_void_p, [
	("L",		ctypes.POINTER(ctypes.c_double)),
	("b",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dSolveL1T = _rpythonic_function_(		"dSolveL1T", ctypes.c_void_p, [
	("L",		ctypes.POINTER(ctypes.c_double)),
	("b",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dVectorScale = _rpythonic_function_(		"dVectorScale", ctypes.c_void_p, [
	("a",		ctypes.POINTER(ctypes.c_double)),
	("d",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dSolveLDLT = _rpythonic_function_(		"dSolveLDLT", ctypes.c_void_p, [
	("L",		ctypes.POINTER(ctypes.c_double)),
	("d",		ctypes.POINTER(ctypes.c_double)),
	("b",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dLDLTAddTL = _rpythonic_function_(		"dLDLTAddTL", ctypes.c_void_p, [
	("L",		ctypes.POINTER(ctypes.c_double)),
	("d",		ctypes.POINTER(ctypes.c_double)),
	("a",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dLDLTRemove = _rpythonic_function_(		"dLDLTRemove", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.POINTER(ctypes.c_double))),
	("p",		ctypes.POINTER(ctypes.c_int)),
	("L",		ctypes.POINTER(ctypes.c_double)),
	("d",		ctypes.POINTER(ctypes.c_double)),
	("n1",		ctypes.c_int),
	("n2",		ctypes.c_int),
	("r",		ctypes.c_int),
	("nskip",		ctypes.c_int),] )

dRemoveRowCol = _rpythonic_function_(		"dRemoveRowCol", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("nskip",		ctypes.c_int),
	("r",		ctypes.c_int),] )

dStopwatchReset = _rpythonic_function_(		"dStopwatchReset", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dStopwatchStart = _rpythonic_function_(		"dStopwatchStart", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dStopwatchStop = _rpythonic_function_(		"dStopwatchStop", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dStopwatchTime = _rpythonic_function_(		"dStopwatchTime", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dTimerStart = _rpythonic_function_(		"dTimerStart", ctypes.c_void_p, [
	("description",		ctypes.POINTER(ctypes.c_char)),] )

dTimerNow = _rpythonic_function_(		"dTimerNow", ctypes.c_void_p, [
	("description",		ctypes.POINTER(ctypes.c_char)),] )

dTimerEnd = _rpythonic_function_(		"dTimerEnd", ctypes.c_void_p, [] )

dTimerReport = _rpythonic_function_(		"dTimerReport", ctypes.c_void_p, [
	("fout",		ctypes.POINTER(_IO_FILE)),
	("average",		ctypes.c_int),] )

dTimerTicksPerSecond = _rpythonic_function_(		"dTimerTicksPerSecond", ctypes.c_double, [] )

dTimerResolution = _rpythonic_function_(		"dTimerResolution", ctypes.c_double, [] )

dRSetIdentity = _rpythonic_function_(		"dRSetIdentity", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),] )

dRFromAxisAndAngle = _rpythonic_function_(		"dRFromAxisAndAngle", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),
	("angle",		ctypes.c_double),] )

dRFromEulerAngles = _rpythonic_function_(		"dRFromEulerAngles", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),
	("phi",		ctypes.c_double),
	("theta",		ctypes.c_double),
	("psi",		ctypes.c_double),] )

dRFrom2Axes = _rpythonic_function_(		"dRFrom2Axes", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),
	("bx",		ctypes.c_double),
	("by",		ctypes.c_double),
	("bz",		ctypes.c_double),] )

dRFromZAxis = _rpythonic_function_(		"dRFromZAxis", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),] )

dQSetIdentity = _rpythonic_function_(		"dQSetIdentity", ctypes.c_void_p, [
	("q",		( ctypes.c_double * 4 )),] )

dQFromAxisAndAngle = _rpythonic_function_(		"dQFromAxisAndAngle", ctypes.c_void_p, [
	("q",		( ctypes.c_double * 4 )),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),
	("angle",		ctypes.c_double),] )

dQMultiply0 = _rpythonic_function_(		"dQMultiply0", ctypes.c_void_p, [
	("qa",		( ctypes.c_double * 4 )),
	("qb",		( ctypes.c_double * 4 )),
	("qc",		( ctypes.c_double * 4 )),] )

dQMultiply1 = _rpythonic_function_(		"dQMultiply1", ctypes.c_void_p, [
	("qa",		( ctypes.c_double * 4 )),
	("qb",		( ctypes.c_double * 4 )),
	("qc",		( ctypes.c_double * 4 )),] )

dQMultiply2 = _rpythonic_function_(		"dQMultiply2", ctypes.c_void_p, [
	("qa",		( ctypes.c_double * 4 )),
	("qb",		( ctypes.c_double * 4 )),
	("qc",		( ctypes.c_double * 4 )),] )

dQMultiply3 = _rpythonic_function_(		"dQMultiply3", ctypes.c_void_p, [
	("qa",		( ctypes.c_double * 4 )),
	("qb",		( ctypes.c_double * 4 )),
	("qc",		( ctypes.c_double * 4 )),] )

dRfromQ = _rpythonic_function_(		"dRfromQ", ctypes.c_void_p, [
	("R",		( ctypes.c_double * 12 )),
	("q",		( ctypes.c_double * 4 )),] )

dQfromR = _rpythonic_function_(		"dQfromR", ctypes.c_void_p, [
	("q",		( ctypes.c_double * 4 )),
	("R",		( ctypes.c_double * 12 )),] )

dDQfromW = _rpythonic_function_(		"dDQfromW", ctypes.c_void_p, [
	("dq",		( ctypes.c_double * 4 )),
	("w",		( ctypes.c_double * 4 )),
	("q",		( ctypes.c_double * 4 )),] )

dMassCheck = _rpythonic_function_(		"dMassCheck", ctypes.c_int, [
	("m",		ctypes.POINTER(dMass)),] )

dMassSetZero = _rpythonic_function_(		"dMassSetZero", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dMassSetParameters = _rpythonic_function_(		"dMassSetParameters", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("themass",		ctypes.c_double),
	("cgx",		ctypes.c_double),
	("cgy",		ctypes.c_double),
	("cgz",		ctypes.c_double),
	("I11",		ctypes.c_double),
	("I22",		ctypes.c_double),
	("I33",		ctypes.c_double),
	("I12",		ctypes.c_double),
	("I13",		ctypes.c_double),
	("I23",		ctypes.c_double),] )

dMassSetSphere = _rpythonic_function_(		"dMassSetSphere", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("density",		ctypes.c_double),
	("radius",		ctypes.c_double),] )

dMassSetSphereTotal = _rpythonic_function_(		"dMassSetSphereTotal", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("total_mass",		ctypes.c_double),
	("radius",		ctypes.c_double),] )

dMassSetCapsule = _rpythonic_function_(		"dMassSetCapsule", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("density",		ctypes.c_double),
	("direction",		ctypes.c_int),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dMassSetCapsuleTotal = _rpythonic_function_(		"dMassSetCapsuleTotal", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("total_mass",		ctypes.c_double),
	("direction",		ctypes.c_int),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dMassSetCylinder = _rpythonic_function_(		"dMassSetCylinder", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("density",		ctypes.c_double),
	("direction",		ctypes.c_int),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dMassSetCylinderTotal = _rpythonic_function_(		"dMassSetCylinderTotal", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("total_mass",		ctypes.c_double),
	("direction",		ctypes.c_int),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dMassSetBox = _rpythonic_function_(		"dMassSetBox", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("density",		ctypes.c_double),
	("lx",		ctypes.c_double),
	("ly",		ctypes.c_double),
	("lz",		ctypes.c_double),] )

dMassSetBoxTotal = _rpythonic_function_(		"dMassSetBoxTotal", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("total_mass",		ctypes.c_double),
	("lx",		ctypes.c_double),
	("ly",		ctypes.c_double),
	("lz",		ctypes.c_double),] )

dMassSetTrimesh = _rpythonic_function_(		"dMassSetTrimesh", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("density",		ctypes.c_double),
	("g",		ctypes.POINTER(dxGeom)),] )

dMassSetTrimeshTotal = _rpythonic_function_(		"dMassSetTrimeshTotal", ctypes.c_void_p, [
	("m",		ctypes.POINTER(dMass)),
	("total_mass",		ctypes.c_double),
	("g",		ctypes.POINTER(dxGeom)),] )

dMassAdjust = _rpythonic_function_(		"dMassAdjust", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("newmass",		ctypes.c_double),] )

dMassTranslate = _rpythonic_function_(		"dMassTranslate", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dMassRotate = _rpythonic_function_(		"dMassRotate", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("R",		( ctypes.c_double * 12 )),] )

dMassAdd = _rpythonic_function_(		"dMassAdd", ctypes.c_void_p, [
	("a",		ctypes.POINTER(dMass)),
	("b",		ctypes.POINTER(dMass)),] )

dMassSetCappedCylinder = _rpythonic_function_(		"dMassSetCappedCylinder", ctypes.c_void_p, [
	("a",		ctypes.POINTER(dMass)),
	("b",		ctypes.c_double),
	("c",		ctypes.c_int),
	("d",		ctypes.c_double),
	("e",		ctypes.c_double),] )

dMassSetCappedCylinderTotal = _rpythonic_function_(		"dMassSetCappedCylinderTotal", ctypes.c_void_p, [
	("a",		ctypes.POINTER(dMass)),
	("b",		ctypes.c_double),
	("c",		ctypes.c_int),
	("d",		ctypes.c_double),
	("e",		ctypes.c_double),] )

dTestRand = _rpythonic_function_(		"dTestRand", ctypes.c_int, [] )

dRand = _rpythonic_function_(		"dRand", ctypes.c_ulong, [] )

dRandGetSeed = _rpythonic_function_(		"dRandGetSeed", ctypes.c_ulong, [] )

dRandSetSeed = _rpythonic_function_(		"dRandSetSeed", ctypes.c_void_p, [
	("s",		ctypes.c_ulong),] )

dRandInt = _rpythonic_function_(		"dRandInt", ctypes.c_int, [
	("n",		ctypes.c_int),] )

dRandReal = _rpythonic_function_(		"dRandReal", ctypes.c_double, [] )

dPrintMatrix = _rpythonic_function_(		"dPrintMatrix", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("m",		ctypes.c_int),
	("fmt",		ctypes.POINTER(ctypes.c_char)),
	("f",		ctypes.POINTER(_IO_FILE)),] )

dMakeRandomVector = _rpythonic_function_(		"dMakeRandomVector", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("range",		ctypes.c_double),] )

dMakeRandomMatrix = _rpythonic_function_(		"dMakeRandomMatrix", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("m",		ctypes.c_int),
	("range",		ctypes.c_double),] )

dClearUpperTriangle = _rpythonic_function_(		"dClearUpperTriangle", ctypes.c_void_p, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dMaxDifference = _rpythonic_function_(		"dMaxDifference", ctypes.c_double, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("B",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),
	("m",		ctypes.c_int),] )

dMaxDifferenceLowerTriangle = _rpythonic_function_(		"dMaxDifferenceLowerTriangle", ctypes.c_double, [
	("A",		ctypes.POINTER(ctypes.c_double)),
	("B",		ctypes.POINTER(ctypes.c_double)),
	("n",		ctypes.c_int),] )

dWorldCreate = _rpythonic_function_(		"dWorldCreate", ctypes.POINTER(ctypes.c_void_p), [] )

dWorldDestroy = _rpythonic_function_(		"dWorldDestroy", ctypes.c_void_p, [
	("world",		ctypes.POINTER(dxWorld)),] )

dWorldSetGravity = _rpythonic_function_(		"dWorldSetGravity", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dWorldGetGravity = _rpythonic_function_(		"dWorldGetGravity", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("gravity",		( ctypes.c_double * 4 )),] )

dWorldSetERP = _rpythonic_function_(		"dWorldSetERP", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("erp",		ctypes.c_double),] )

dWorldGetERP = _rpythonic_function_(		"dWorldGetERP", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetCFM = _rpythonic_function_(		"dWorldSetCFM", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("cfm",		ctypes.c_double),] )

dWorldGetCFM = _rpythonic_function_(		"dWorldGetCFM", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldStep = _rpythonic_function_(		"dWorldStep", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("stepsize",		ctypes.c_double),] )

dWorldImpulseToForce = _rpythonic_function_(		"dWorldImpulseToForce", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("stepsize",		ctypes.c_double),
	("ix",		ctypes.c_double),
	("iy",		ctypes.c_double),
	("iz",		ctypes.c_double),
	("force",		( ctypes.c_double * 4 )),] )

dWorldQuickStep = _rpythonic_function_(		"dWorldQuickStep", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("stepsize",		ctypes.c_double),] )

dWorldSetQuickStepNumIterations = _rpythonic_function_(		"dWorldSetQuickStepNumIterations", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("num",		ctypes.c_int),] )

dWorldGetQuickStepNumIterations = _rpythonic_function_(		"dWorldGetQuickStepNumIterations", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetQuickStepW = _rpythonic_function_(		"dWorldSetQuickStepW", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("over_relaxation",		ctypes.c_double),] )

dWorldGetQuickStepW = _rpythonic_function_(		"dWorldGetQuickStepW", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetContactMaxCorrectingVel = _rpythonic_function_(		"dWorldSetContactMaxCorrectingVel", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("vel",		ctypes.c_double),] )

dWorldGetContactMaxCorrectingVel = _rpythonic_function_(		"dWorldGetContactMaxCorrectingVel", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetContactSurfaceLayer = _rpythonic_function_(		"dWorldSetContactSurfaceLayer", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("depth",		ctypes.c_double),] )

dWorldGetContactSurfaceLayer = _rpythonic_function_(		"dWorldGetContactSurfaceLayer", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldStepFast1 = _rpythonic_function_(		"dWorldStepFast1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("stepsize",		ctypes.c_double),
	("maxiterations",		ctypes.c_int),] )

dWorldSetAutoEnableDepthSF1 = _rpythonic_function_(		"dWorldSetAutoEnableDepthSF1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("autoEnableDepth",		ctypes.c_int),] )

dWorldGetAutoEnableDepthSF1 = _rpythonic_function_(		"dWorldGetAutoEnableDepthSF1", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldGetAutoDisableLinearThreshold = _rpythonic_function_(		"dWorldGetAutoDisableLinearThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableLinearThreshold = _rpythonic_function_(		"dWorldSetAutoDisableLinearThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("linear_threshold",		ctypes.c_double),] )

dWorldGetAutoDisableAngularThreshold = _rpythonic_function_(		"dWorldGetAutoDisableAngularThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableAngularThreshold = _rpythonic_function_(		"dWorldSetAutoDisableAngularThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("angular_threshold",		ctypes.c_double),] )

dWorldGetAutoDisableLinearAverageThreshold = _rpythonic_function_(		"dWorldGetAutoDisableLinearAverageThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableLinearAverageThreshold = _rpythonic_function_(		"dWorldSetAutoDisableLinearAverageThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("linear_average_threshold",		ctypes.c_double),] )

dWorldGetAutoDisableAngularAverageThreshold = _rpythonic_function_(		"dWorldGetAutoDisableAngularAverageThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableAngularAverageThreshold = _rpythonic_function_(		"dWorldSetAutoDisableAngularAverageThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("angular_average_threshold",		ctypes.c_double),] )

dWorldGetAutoDisableAverageSamplesCount = _rpythonic_function_(		"dWorldGetAutoDisableAverageSamplesCount", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableAverageSamplesCount = _rpythonic_function_(		"dWorldSetAutoDisableAverageSamplesCount", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("average_samples_count",		ctypes.c_uint),] )

dWorldGetAutoDisableSteps = _rpythonic_function_(		"dWorldGetAutoDisableSteps", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableSteps = _rpythonic_function_(		"dWorldSetAutoDisableSteps", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("steps",		ctypes.c_int),] )

dWorldGetAutoDisableTime = _rpythonic_function_(		"dWorldGetAutoDisableTime", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableTime = _rpythonic_function_(		"dWorldSetAutoDisableTime", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("time",		ctypes.c_double),] )

dWorldGetAutoDisableFlag = _rpythonic_function_(		"dWorldGetAutoDisableFlag", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dWorldSetAutoDisableFlag = _rpythonic_function_(		"dWorldSetAutoDisableFlag", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("do_auto_disable",		ctypes.c_int),] )

dWorldGetLinearDampingThreshold = _rpythonic_function_(		"dWorldGetLinearDampingThreshold", ctypes.c_double, [
	("w",		ctypes.POINTER(dxWorld)),] )

dWorldSetLinearDampingThreshold = _rpythonic_function_(		"dWorldSetLinearDampingThreshold", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("threshold",		ctypes.c_double),] )

dWorldGetAngularDampingThreshold = _rpythonic_function_(		"dWorldGetAngularDampingThreshold", ctypes.c_double, [
	("w",		ctypes.POINTER(dxWorld)),] )

dWorldSetAngularDampingThreshold = _rpythonic_function_(		"dWorldSetAngularDampingThreshold", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("threshold",		ctypes.c_double),] )

dWorldGetLinearDamping = _rpythonic_function_(		"dWorldGetLinearDamping", ctypes.c_double, [
	("w",		ctypes.POINTER(dxWorld)),] )

dWorldSetLinearDamping = _rpythonic_function_(		"dWorldSetLinearDamping", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("scale",		ctypes.c_double),] )

dWorldGetAngularDamping = _rpythonic_function_(		"dWorldGetAngularDamping", ctypes.c_double, [
	("w",		ctypes.POINTER(dxWorld)),] )

dWorldSetAngularDamping = _rpythonic_function_(		"dWorldSetAngularDamping", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("scale",		ctypes.c_double),] )

dWorldSetDamping = _rpythonic_function_(		"dWorldSetDamping", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("linear_scale",		ctypes.c_double),
	("angular_scale",		ctypes.c_double),] )

dWorldGetMaxAngularSpeed = _rpythonic_function_(		"dWorldGetMaxAngularSpeed", ctypes.c_double, [
	("w",		ctypes.POINTER(dxWorld)),] )

dWorldSetMaxAngularSpeed = _rpythonic_function_(		"dWorldSetMaxAngularSpeed", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("max_speed",		ctypes.c_double),] )

dBodyGetAutoDisableLinearThreshold = _rpythonic_function_(		"dBodyGetAutoDisableLinearThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableLinearThreshold = _rpythonic_function_(		"dBodySetAutoDisableLinearThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("linear_average_threshold",		ctypes.c_double),] )

dBodyGetAutoDisableAngularThreshold = _rpythonic_function_(		"dBodyGetAutoDisableAngularThreshold", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableAngularThreshold = _rpythonic_function_(		"dBodySetAutoDisableAngularThreshold", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("angular_average_threshold",		ctypes.c_double),] )

dBodyGetAutoDisableAverageSamplesCount = _rpythonic_function_(		"dBodyGetAutoDisableAverageSamplesCount", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableAverageSamplesCount = _rpythonic_function_(		"dBodySetAutoDisableAverageSamplesCount", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("average_samples_count",		ctypes.c_uint),] )

dBodyGetAutoDisableSteps = _rpythonic_function_(		"dBodyGetAutoDisableSteps", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableSteps = _rpythonic_function_(		"dBodySetAutoDisableSteps", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("steps",		ctypes.c_int),] )

dBodyGetAutoDisableTime = _rpythonic_function_(		"dBodyGetAutoDisableTime", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableTime = _rpythonic_function_(		"dBodySetAutoDisableTime", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("time",		ctypes.c_double),] )

dBodyGetAutoDisableFlag = _rpythonic_function_(		"dBodyGetAutoDisableFlag", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetAutoDisableFlag = _rpythonic_function_(		"dBodySetAutoDisableFlag", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("do_auto_disable",		ctypes.c_int),] )

dBodySetAutoDisableDefaults = _rpythonic_function_(		"dBodySetAutoDisableDefaults", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetWorld = _rpythonic_function_(		"dBodyGetWorld", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyCreate = _rpythonic_function_(		"dBodyCreate", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyDestroy = _rpythonic_function_(		"dBodyDestroy", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetData = _rpythonic_function_(		"dBodySetData", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("data",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetData = _rpythonic_function_(		"dBodyGetData", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetPosition = _rpythonic_function_(		"dBodySetPosition", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodySetRotation = _rpythonic_function_(		"dBodySetRotation", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("R",		( ctypes.c_double * 12 )),] )

dBodySetQuaternion = _rpythonic_function_(		"dBodySetQuaternion", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("q",		( ctypes.c_double * 4 )),] )

dBodySetLinearVel = _rpythonic_function_(		"dBodySetLinearVel", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodySetAngularVel = _rpythonic_function_(		"dBodySetAngularVel", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodyGetPosition = _rpythonic_function_(		"dBodyGetPosition", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyCopyPosition = _rpythonic_function_(		"dBodyCopyPosition", ctypes.c_void_p, [
	("body",		ctypes.POINTER(dxBody)),
	("pos",		( ctypes.c_double * 4 )),] )

dBodyGetRotation = _rpythonic_function_(		"dBodyGetRotation", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyCopyRotation = _rpythonic_function_(		"dBodyCopyRotation", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("R",		( ctypes.c_double * 12 )),] )

dBodyGetQuaternion = _rpythonic_function_(		"dBodyGetQuaternion", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyCopyQuaternion = _rpythonic_function_(		"dBodyCopyQuaternion", ctypes.c_void_p, [
	("body",		ctypes.POINTER(dxBody)),
	("quat",		( ctypes.c_double * 4 )),] )

dBodyGetLinearVel = _rpythonic_function_(		"dBodyGetLinearVel", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetAngularVel = _rpythonic_function_(		"dBodyGetAngularVel", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetMass = _rpythonic_function_(		"dBodySetMass", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("mass",		ctypes.POINTER(dMass)),] )

dBodyGetMass = _rpythonic_function_(		"dBodyGetMass", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("mass",		ctypes.POINTER(dMass)),] )

dBodyAddForce = _rpythonic_function_(		"dBodyAddForce", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),] )

dBodyAddTorque = _rpythonic_function_(		"dBodyAddTorque", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),] )

dBodyAddRelForce = _rpythonic_function_(		"dBodyAddRelForce", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),] )

dBodyAddRelTorque = _rpythonic_function_(		"dBodyAddRelTorque", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),] )

dBodyAddForceAtPos = _rpythonic_function_(		"dBodyAddForceAtPos", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),] )

dBodyAddForceAtRelPos = _rpythonic_function_(		"dBodyAddForceAtRelPos", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),] )

dBodyAddRelForceAtPos = _rpythonic_function_(		"dBodyAddRelForceAtPos", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),] )

dBodyAddRelForceAtRelPos = _rpythonic_function_(		"dBodyAddRelForceAtRelPos", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("fx",		ctypes.c_double),
	("fy",		ctypes.c_double),
	("fz",		ctypes.c_double),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),] )

dBodyGetForce = _rpythonic_function_(		"dBodyGetForce", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetTorque = _rpythonic_function_(		"dBodyGetTorque", ctypes.POINTER(ctypes.c_double), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetForce = _rpythonic_function_(		"dBodySetForce", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodySetTorque = _rpythonic_function_(		"dBodySetTorque", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodyGetRelPointPos = _rpythonic_function_(		"dBodyGetRelPointPos", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodyGetRelPointVel = _rpythonic_function_(		"dBodyGetRelPointVel", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodyGetPointVel = _rpythonic_function_(		"dBodyGetPointVel", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodyGetPosRelPoint = _rpythonic_function_(		"dBodyGetPosRelPoint", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodyVectorToWorld = _rpythonic_function_(		"dBodyVectorToWorld", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodyVectorFromWorld = _rpythonic_function_(		"dBodyVectorFromWorld", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("result",		( ctypes.c_double * 4 )),] )

dBodySetFiniteRotationMode = _rpythonic_function_(		"dBodySetFiniteRotationMode", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("mode",		ctypes.c_int),] )

dBodySetFiniteRotationAxis = _rpythonic_function_(		"dBodySetFiniteRotationAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dBodyGetFiniteRotationMode = _rpythonic_function_(		"dBodyGetFiniteRotationMode", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetFiniteRotationAxis = _rpythonic_function_(		"dBodyGetFiniteRotationAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dBodyGetNumJoints = _rpythonic_function_(		"dBodyGetNumJoints", ctypes.c_int, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodyGetJoint = _rpythonic_function_(		"dBodyGetJoint", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("index",		ctypes.c_int),] )

dBodySetDynamic = _rpythonic_function_(		"dBodySetDynamic", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetKinematic = _rpythonic_function_(		"dBodySetKinematic", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyIsKinematic = _rpythonic_function_(		"dBodyIsKinematic", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyEnable = _rpythonic_function_(		"dBodyEnable", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyDisable = _rpythonic_function_(		"dBodyDisable", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyIsEnabled = _rpythonic_function_(		"dBodyIsEnabled", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodySetGravityMode = _rpythonic_function_(		"dBodySetGravityMode", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("mode",		ctypes.c_int),] )

dBodyGetGravityMode = _rpythonic_function_(		"dBodyGetGravityMode", ctypes.c_int, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetMovedCallback = _rpythonic_function_(		"dBodySetMovedCallback", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("callback",		ctypes.c_void_p),] )

callback = _rpythonic_function_(		"callback", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dBodyGetFirstGeom = _rpythonic_function_(		"dBodyGetFirstGeom", ctypes.POINTER(ctypes.c_void_p), [
	("b",		ctypes.POINTER(dxBody)),] )

dBodyGetNextGeom = _rpythonic_function_(		"dBodyGetNextGeom", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxGeom)),] )

dBodySetDampingDefaults = _rpythonic_function_(		"dBodySetDampingDefaults", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodyGetLinearDamping = _rpythonic_function_(		"dBodyGetLinearDamping", ctypes.c_double, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetLinearDamping = _rpythonic_function_(		"dBodySetLinearDamping", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("scale",		ctypes.c_double),] )

dBodyGetAngularDamping = _rpythonic_function_(		"dBodyGetAngularDamping", ctypes.c_double, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetAngularDamping = _rpythonic_function_(		"dBodySetAngularDamping", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("scale",		ctypes.c_double),] )

dBodySetDamping = _rpythonic_function_(		"dBodySetDamping", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("linear_scale",		ctypes.c_double),
	("angular_scale",		ctypes.c_double),] )

dBodyGetLinearDampingThreshold = _rpythonic_function_(		"dBodyGetLinearDampingThreshold", ctypes.c_double, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetLinearDampingThreshold = _rpythonic_function_(		"dBodySetLinearDampingThreshold", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("threshold",		ctypes.c_double),] )

dBodyGetAngularDampingThreshold = _rpythonic_function_(		"dBodyGetAngularDampingThreshold", ctypes.c_double, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetAngularDampingThreshold = _rpythonic_function_(		"dBodySetAngularDampingThreshold", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("threshold",		ctypes.c_double),] )

dBodyGetMaxAngularSpeed = _rpythonic_function_(		"dBodyGetMaxAngularSpeed", ctypes.c_double, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetMaxAngularSpeed = _rpythonic_function_(		"dBodySetMaxAngularSpeed", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("max_speed",		ctypes.c_double),] )

dBodyGetGyroscopicMode = _rpythonic_function_(		"dBodyGetGyroscopicMode", ctypes.c_int, [
	("b",		ctypes.POINTER(dxBody)),] )

dBodySetGyroscopicMode = _rpythonic_function_(		"dBodySetGyroscopicMode", ctypes.c_void_p, [
	("b",		ctypes.POINTER(dxBody)),
	("enabled",		ctypes.c_int),] )

dJointCreateBall = _rpythonic_function_(		"dJointCreateBall", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateHinge = _rpythonic_function_(		"dJointCreateHinge", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateSlider = _rpythonic_function_(		"dJointCreateSlider", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateContact = _rpythonic_function_(		"dJointCreateContact", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateHinge2 = _rpythonic_function_(		"dJointCreateHinge2", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateUniversal = _rpythonic_function_(		"dJointCreateUniversal", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreatePR = _rpythonic_function_(		"dJointCreatePR", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreatePU = _rpythonic_function_(		"dJointCreatePU", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreatePiston = _rpythonic_function_(		"dJointCreatePiston", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateFixed = _rpythonic_function_(		"dJointCreateFixed", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateNull = _rpythonic_function_(		"dJointCreateNull", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateAMotor = _rpythonic_function_(		"dJointCreateAMotor", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreateLMotor = _rpythonic_function_(		"dJointCreateLMotor", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointCreatePlane2D = _rpythonic_function_(		"dJointCreatePlane2D", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointDestroy = _rpythonic_function_(		"dJointDestroy", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGroupCreate = _rpythonic_function_(		"dJointGroupCreate", ctypes.POINTER(ctypes.c_void_p), [
	("max_size",		ctypes.c_int),] )

dJointGroupDestroy = _rpythonic_function_(		"dJointGroupDestroy", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGroupEmpty = _rpythonic_function_(		"dJointGroupEmpty", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetNumBodies = _rpythonic_function_(		"dJointGetNumBodies", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointAttach = _rpythonic_function_(		"dJointAttach", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("body1",		ctypes.POINTER(dxBody)),
	("body2",		ctypes.POINTER(dxBody)),] )

dJointEnable = _rpythonic_function_(		"dJointEnable", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointDisable = _rpythonic_function_(		"dJointDisable", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointIsEnabled = _rpythonic_function_(		"dJointIsEnabled", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointSetData = _rpythonic_function_(		"dJointSetData", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("data",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetData = _rpythonic_function_(		"dJointGetData", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetType = _rpythonic_function_(		"dJointGetType", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetBody = _rpythonic_function_(		"dJointGetBody", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("index",		ctypes.c_int),] )

dJointSetFeedback = _rpythonic_function_(		"dJointSetFeedback", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetFeedback = _rpythonic_function_(		"dJointGetFeedback", ctypes.POINTER(dJointFeedback), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointSetBallAnchor = _rpythonic_function_(		"dJointSetBallAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetBallAnchor2 = _rpythonic_function_(		"dJointSetBallAnchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetBallParam = _rpythonic_function_(		"dJointSetBallParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetHingeAnchor = _rpythonic_function_(		"dJointSetHingeAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetHingeAnchorDelta = _rpythonic_function_(		"dJointSetHingeAnchorDelta", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),] )

dJointSetHingeAxis = _rpythonic_function_(		"dJointSetHingeAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetHingeAxisOffset = _rpythonic_function_(		"dJointSetHingeAxisOffset", ctypes.c_void_p, [
	("j",		ctypes.POINTER(dxJoint)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("angle",		ctypes.c_double),] )

dJointSetHingeParam = _rpythonic_function_(		"dJointSetHingeParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddHingeTorque = _rpythonic_function_(		"dJointAddHingeTorque", ctypes.c_void_p, [
	("joint",		ctypes.POINTER(dxJoint)),
	("torque",		ctypes.c_double),] )

dJointSetSliderAxis = _rpythonic_function_(		"dJointSetSliderAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetSliderAxisDelta = _rpythonic_function_(		"dJointSetSliderAxisDelta", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),] )

dJointSetSliderParam = _rpythonic_function_(		"dJointSetSliderParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddSliderForce = _rpythonic_function_(		"dJointAddSliderForce", ctypes.c_void_p, [
	("joint",		ctypes.POINTER(dxJoint)),
	("force",		ctypes.c_double),] )

dJointSetHinge2Anchor = _rpythonic_function_(		"dJointSetHinge2Anchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetHinge2Axis1 = _rpythonic_function_(		"dJointSetHinge2Axis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetHinge2Axis2 = _rpythonic_function_(		"dJointSetHinge2Axis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetHinge2Param = _rpythonic_function_(		"dJointSetHinge2Param", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddHinge2Torques = _rpythonic_function_(		"dJointAddHinge2Torques", ctypes.c_void_p, [
	("joint",		ctypes.POINTER(dxJoint)),
	("torque1",		ctypes.c_double),
	("torque2",		ctypes.c_double),] )

dJointSetUniversalAnchor = _rpythonic_function_(		"dJointSetUniversalAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetUniversalAxis1 = _rpythonic_function_(		"dJointSetUniversalAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetUniversalAxis1Offset = _rpythonic_function_(		"dJointSetUniversalAxis1Offset", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("offset1",		ctypes.c_double),
	("offset2",		ctypes.c_double),] )

dJointSetUniversalAxis2 = _rpythonic_function_(		"dJointSetUniversalAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetUniversalAxis2Offset = _rpythonic_function_(		"dJointSetUniversalAxis2Offset", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("offset1",		ctypes.c_double),
	("offset2",		ctypes.c_double),] )

dJointSetUniversalParam = _rpythonic_function_(		"dJointSetUniversalParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddUniversalTorques = _rpythonic_function_(		"dJointAddUniversalTorques", ctypes.c_void_p, [
	("joint",		ctypes.POINTER(dxJoint)),
	("torque1",		ctypes.c_double),
	("torque2",		ctypes.c_double),] )

dJointSetPRAnchor = _rpythonic_function_(		"dJointSetPRAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPRAxis1 = _rpythonic_function_(		"dJointSetPRAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPRAxis2 = _rpythonic_function_(		"dJointSetPRAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPRParam = _rpythonic_function_(		"dJointSetPRParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddPRTorque = _rpythonic_function_(		"dJointAddPRTorque", ctypes.c_void_p, [
	("j",		ctypes.POINTER(dxJoint)),
	("torque",		ctypes.c_double),] )

dJointSetPUAnchor = _rpythonic_function_(		"dJointSetPUAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPUAnchorDelta = _rpythonic_function_(		"dJointSetPUAnchorDelta", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("dx",		ctypes.c_double),
	("dy",		ctypes.c_double),
	("dz",		ctypes.c_double),] )

dJointSetPUAnchorOffset = _rpythonic_function_(		"dJointSetPUAnchorOffset", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("dx",		ctypes.c_double),
	("dy",		ctypes.c_double),
	("dz",		ctypes.c_double),] )

dJointSetPUAxis1 = _rpythonic_function_(		"dJointSetPUAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPUAxis2 = _rpythonic_function_(		"dJointSetPUAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPUAxis3 = _rpythonic_function_(		"dJointSetPUAxis3", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPUAxisP = _rpythonic_function_(		"dJointSetPUAxisP", ctypes.c_void_p, [
	("C_id",		ctypes.POINTER(dxJoint)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPUParam = _rpythonic_function_(		"dJointSetPUParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddPUTorque = _rpythonic_function_(		"dJointAddPUTorque", ctypes.c_void_p, [
	("j",		ctypes.POINTER(dxJoint)),
	("torque",		ctypes.c_double),] )

dJointSetPistonAnchor = _rpythonic_function_(		"dJointSetPistonAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPistonAnchorOffset = _rpythonic_function_(		"dJointSetPistonAnchorOffset", ctypes.c_void_p, [
	("j",		ctypes.POINTER(dxJoint)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("dx",		ctypes.c_double),
	("dy",		ctypes.c_double),
	("dz",		ctypes.c_double),] )

dJointSetPistonAxis = _rpythonic_function_(		"dJointSetPistonAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetPistonAxisDelta = _rpythonic_function_(		"dJointSetPistonAxisDelta", ctypes.c_void_p, [
	("j",		ctypes.POINTER(dxJoint)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),
	("ax",		ctypes.c_double),
	("ay",		ctypes.c_double),
	("az",		ctypes.c_double),] )

dJointSetPistonParam = _rpythonic_function_(		"dJointSetPistonParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointAddPistonForce = _rpythonic_function_(		"dJointAddPistonForce", ctypes.c_void_p, [
	("joint",		ctypes.POINTER(dxJoint)),
	("force",		ctypes.c_double),] )

dJointSetFixed = _rpythonic_function_(		"dJointSetFixed", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointSetFixedParam = _rpythonic_function_(		"dJointSetFixedParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetAMotorNumAxes = _rpythonic_function_(		"dJointSetAMotorNumAxes", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("num",		ctypes.c_int),] )

dJointSetAMotorAxis = _rpythonic_function_(		"dJointSetAMotorAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),
	("rel",		ctypes.c_int),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetAMotorAngle = _rpythonic_function_(		"dJointSetAMotorAngle", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),
	("angle",		ctypes.c_double),] )

dJointSetAMotorParam = _rpythonic_function_(		"dJointSetAMotorParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetAMotorMode = _rpythonic_function_(		"dJointSetAMotorMode", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("mode",		ctypes.c_int),] )

dJointAddAMotorTorques = _rpythonic_function_(		"dJointAddAMotorTorques", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("torque1",		ctypes.c_double),
	("torque2",		ctypes.c_double),
	("torque3",		ctypes.c_double),] )

dJointSetLMotorNumAxes = _rpythonic_function_(		"dJointSetLMotorNumAxes", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("num",		ctypes.c_int),] )

dJointSetLMotorAxis = _rpythonic_function_(		"dJointSetLMotorAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),
	("rel",		ctypes.c_int),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dJointSetLMotorParam = _rpythonic_function_(		"dJointSetLMotorParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetPlane2DXParam = _rpythonic_function_(		"dJointSetPlane2DXParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetPlane2DYParam = _rpythonic_function_(		"dJointSetPlane2DYParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointSetPlane2DAngleParam = _rpythonic_function_(		"dJointSetPlane2DAngleParam", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),
	("value",		ctypes.c_double),] )

dJointGetBallAnchor = _rpythonic_function_(		"dJointGetBallAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetBallAnchor2 = _rpythonic_function_(		"dJointGetBallAnchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetBallParam = _rpythonic_function_(		"dJointGetBallParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetHingeAnchor = _rpythonic_function_(		"dJointGetHingeAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHingeAnchor2 = _rpythonic_function_(		"dJointGetHingeAnchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHingeAxis = _rpythonic_function_(		"dJointGetHingeAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHingeParam = _rpythonic_function_(		"dJointGetHingeParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetHingeAngle = _rpythonic_function_(		"dJointGetHingeAngle", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetHingeAngleRate = _rpythonic_function_(		"dJointGetHingeAngleRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetSliderPosition = _rpythonic_function_(		"dJointGetSliderPosition", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetSliderPositionRate = _rpythonic_function_(		"dJointGetSliderPositionRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetSliderAxis = _rpythonic_function_(		"dJointGetSliderAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetSliderParam = _rpythonic_function_(		"dJointGetSliderParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetHinge2Anchor = _rpythonic_function_(		"dJointGetHinge2Anchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHinge2Anchor2 = _rpythonic_function_(		"dJointGetHinge2Anchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHinge2Axis1 = _rpythonic_function_(		"dJointGetHinge2Axis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHinge2Axis2 = _rpythonic_function_(		"dJointGetHinge2Axis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetHinge2Param = _rpythonic_function_(		"dJointGetHinge2Param", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetHinge2Angle1 = _rpythonic_function_(		"dJointGetHinge2Angle1", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetHinge2Angle1Rate = _rpythonic_function_(		"dJointGetHinge2Angle1Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetHinge2Angle2Rate = _rpythonic_function_(		"dJointGetHinge2Angle2Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetUniversalAnchor = _rpythonic_function_(		"dJointGetUniversalAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetUniversalAnchor2 = _rpythonic_function_(		"dJointGetUniversalAnchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetUniversalAxis1 = _rpythonic_function_(		"dJointGetUniversalAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetUniversalAxis2 = _rpythonic_function_(		"dJointGetUniversalAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetUniversalParam = _rpythonic_function_(		"dJointGetUniversalParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetUniversalAngles = _rpythonic_function_(		"dJointGetUniversalAngles", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("angle1",		ctypes.POINTER(ctypes.c_double)),
	("angle2",		ctypes.POINTER(ctypes.c_double)),] )

dJointGetUniversalAngle1 = _rpythonic_function_(		"dJointGetUniversalAngle1", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetUniversalAngle2 = _rpythonic_function_(		"dJointGetUniversalAngle2", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetUniversalAngle1Rate = _rpythonic_function_(		"dJointGetUniversalAngle1Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetUniversalAngle2Rate = _rpythonic_function_(		"dJointGetUniversalAngle2Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPRAnchor = _rpythonic_function_(		"dJointGetPRAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPRPosition = _rpythonic_function_(		"dJointGetPRPosition", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPRPositionRate = _rpythonic_function_(		"dJointGetPRPositionRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPRAngle = _rpythonic_function_(		"dJointGetPRAngle", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPRAngleRate = _rpythonic_function_(		"dJointGetPRAngleRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPRAxis1 = _rpythonic_function_(		"dJointGetPRAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPRAxis2 = _rpythonic_function_(		"dJointGetPRAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPRParam = _rpythonic_function_(		"dJointGetPRParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetPUAnchor = _rpythonic_function_(		"dJointGetPUAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPUPosition = _rpythonic_function_(		"dJointGetPUPosition", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUPositionRate = _rpythonic_function_(		"dJointGetPUPositionRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUAxis1 = _rpythonic_function_(		"dJointGetPUAxis1", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPUAxis2 = _rpythonic_function_(		"dJointGetPUAxis2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPUAxis3 = _rpythonic_function_(		"dJointGetPUAxis3", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPUAxisP = _rpythonic_function_(		"dJointGetPUAxisP", ctypes.c_void_p, [
	("C_id",		ctypes.POINTER(dxJoint)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPUAngles = _rpythonic_function_(		"dJointGetPUAngles", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("angle1",		ctypes.POINTER(ctypes.c_double)),
	("angle2",		ctypes.POINTER(ctypes.c_double)),] )

dJointGetPUAngle1 = _rpythonic_function_(		"dJointGetPUAngle1", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUAngle1Rate = _rpythonic_function_(		"dJointGetPUAngle1Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUAngle2 = _rpythonic_function_(		"dJointGetPUAngle2", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUAngle2Rate = _rpythonic_function_(		"dJointGetPUAngle2Rate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPUParam = _rpythonic_function_(		"dJointGetPUParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetPistonPosition = _rpythonic_function_(		"dJointGetPistonPosition", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPistonPositionRate = _rpythonic_function_(		"dJointGetPistonPositionRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPistonAngle = _rpythonic_function_(		"dJointGetPistonAngle", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPistonAngleRate = _rpythonic_function_(		"dJointGetPistonAngleRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetPistonAnchor = _rpythonic_function_(		"dJointGetPistonAnchor", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPistonAnchor2 = _rpythonic_function_(		"dJointGetPistonAnchor2", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPistonAxis = _rpythonic_function_(		"dJointGetPistonAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetPistonParam = _rpythonic_function_(		"dJointGetPistonParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetAMotorNumAxes = _rpythonic_function_(		"dJointGetAMotorNumAxes", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetAMotorAxis = _rpythonic_function_(		"dJointGetAMotorAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetAMotorAxisRel = _rpythonic_function_(		"dJointGetAMotorAxisRel", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),] )

dJointGetAMotorAngle = _rpythonic_function_(		"dJointGetAMotorAngle", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),] )

dJointGetAMotorAngleRate = _rpythonic_function_(		"dJointGetAMotorAngleRate", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),] )

dJointGetAMotorParam = _rpythonic_function_(		"dJointGetAMotorParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetAMotorMode = _rpythonic_function_(		"dJointGetAMotorMode", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetLMotorNumAxes = _rpythonic_function_(		"dJointGetLMotorNumAxes", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dJointGetLMotorAxis = _rpythonic_function_(		"dJointGetLMotorAxis", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("anum",		ctypes.c_int),
	("result",		( ctypes.c_double * 4 )),] )

dJointGetLMotorParam = _rpythonic_function_(		"dJointGetLMotorParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dJointGetFixedParam = _rpythonic_function_(		"dJointGetFixedParam", ctypes.c_double, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("parameter",		ctypes.c_int),] )

dConnectingJoint = _rpythonic_function_(		"dConnectingJoint", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dConnectingJointList = _rpythonic_function_(		"dConnectingJointList", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.POINTER(ctypes.c_void_p))),] )

dAreConnected = _rpythonic_function_(		"dAreConnected", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dAreConnectedExcluding = _rpythonic_function_(		"dAreConnectedExcluding", ctypes.c_int, [
	("body1",		ctypes.POINTER(dxBody)),
	("body2",		ctypes.POINTER(dxBody)),
	("joint_type",		ctypes.c_int),] )

dNearCallback = _rpythonic_function_(		"dNearCallback", ctypes.c_void_p, [
	("data",		ctypes.POINTER(ctypes.c_void_p)),
	("o1",		ctypes.POINTER(dxGeom)),
	("o2",		ctypes.POINTER(dxGeom)),] )

dSimpleSpaceCreate = _rpythonic_function_(		"dSimpleSpaceCreate", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),] )

dHashSpaceCreate = _rpythonic_function_(		"dHashSpaceCreate", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),] )

dQuadTreeSpaceCreate = _rpythonic_function_(		"dQuadTreeSpaceCreate", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("Center",		( ctypes.c_double * 4 )),
	("Extents",		( ctypes.c_double * 4 )),
	("Depth",		ctypes.c_int),] )

dSweepAndPruneSpaceCreate = _rpythonic_function_(		"dSweepAndPruneSpaceCreate", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("axisorder",		ctypes.c_int),] )

dSpaceDestroy = _rpythonic_function_(		"dSpaceDestroy", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dHashSpaceSetLevels = _rpythonic_function_(		"dHashSpaceSetLevels", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("minlevel",		ctypes.c_int),
	("maxlevel",		ctypes.c_int),] )

dHashSpaceGetLevels = _rpythonic_function_(		"dHashSpaceGetLevels", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("minlevel",		ctypes.POINTER(ctypes.c_int)),
	("maxlevel",		ctypes.POINTER(ctypes.c_int)),] )

dSpaceSetCleanup = _rpythonic_function_(		"dSpaceSetCleanup", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("mode",		ctypes.c_int),] )

dSpaceGetCleanup = _rpythonic_function_(		"dSpaceGetCleanup", ctypes.c_int, [
	("space",		ctypes.POINTER(dxSpace)),] )

dSpaceSetSublevel = _rpythonic_function_(		"dSpaceSetSublevel", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("sublevel",		ctypes.c_int),] )

dSpaceGetSublevel = _rpythonic_function_(		"dSpaceGetSublevel", ctypes.c_int, [
	("space",		ctypes.POINTER(dxSpace)),] )

dSpaceSetManualCleanup = _rpythonic_function_(		"dSpaceSetManualCleanup", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("mode",		ctypes.c_int),] )

dSpaceGetManualCleanup = _rpythonic_function_(		"dSpaceGetManualCleanup", ctypes.c_int, [
	("space",		ctypes.POINTER(dxSpace)),] )

dSpaceAdd = _rpythonic_function_(		"dSpaceAdd", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dSpaceRemove = _rpythonic_function_(		"dSpaceRemove", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dSpaceQuery = _rpythonic_function_(		"dSpaceQuery", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dSpaceClean = _rpythonic_function_(		"dSpaceClean", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dSpaceGetNumGeoms = _rpythonic_function_(		"dSpaceGetNumGeoms", ctypes.c_int, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dSpaceGetGeom = _rpythonic_function_(		"dSpaceGetGeom", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("i",		ctypes.c_int),] )

dSpaceGetClass = _rpythonic_function_(		"dSpaceGetClass", ctypes.c_int, [
	("space",		ctypes.POINTER(dxSpace)),] )

dGeomDestroy = _rpythonic_function_(		"dGeomDestroy", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomSetData = _rpythonic_function_(		"dGeomSetData", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("data",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomGetData = _rpythonic_function_(		"dGeomGetData", ctypes.POINTER(ctypes.c_void_p), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomSetBody = _rpythonic_function_(		"dGeomSetBody", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("body",		ctypes.POINTER(dxBody)),] )

dGeomGetBody = _rpythonic_function_(		"dGeomGetBody", ctypes.POINTER(ctypes.c_void_p), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomSetPosition = _rpythonic_function_(		"dGeomSetPosition", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dGeomSetRotation = _rpythonic_function_(		"dGeomSetRotation", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("R",		( ctypes.c_double * 12 )),] )

dGeomSetQuaternion = _rpythonic_function_(		"dGeomSetQuaternion", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("Q",		( ctypes.c_double * 4 )),] )

dGeomGetPosition = _rpythonic_function_(		"dGeomGetPosition", ctypes.POINTER(ctypes.c_double), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomCopyPosition = _rpythonic_function_(		"dGeomCopyPosition", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("pos",		( ctypes.c_double * 4 )),] )

dGeomGetRotation = _rpythonic_function_(		"dGeomGetRotation", ctypes.POINTER(ctypes.c_double), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomCopyRotation = _rpythonic_function_(		"dGeomCopyRotation", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("R",		( ctypes.c_double * 12 )),] )

dGeomGetQuaternion = _rpythonic_function_(		"dGeomGetQuaternion", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("result",		( ctypes.c_double * 4 )),] )

dGeomGetAABB = _rpythonic_function_(		"dGeomGetAABB", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("aabb",		( ctypes.c_double * 6 )),] )

dGeomIsSpace = _rpythonic_function_(		"dGeomIsSpace", ctypes.c_int, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomGetSpace = _rpythonic_function_(		"dGeomGetSpace", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomGetClass = _rpythonic_function_(		"dGeomGetClass", ctypes.c_int, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomSetCategoryBits = _rpythonic_function_(		"dGeomSetCategoryBits", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("bits",		ctypes.c_ulong),] )

dGeomSetCollideBits = _rpythonic_function_(		"dGeomSetCollideBits", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("bits",		ctypes.c_ulong),] )

dGeomGetCategoryBits = _rpythonic_function_(		"dGeomGetCategoryBits", ctypes.c_ulong, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomGetCollideBits = _rpythonic_function_(		"dGeomGetCollideBits", ctypes.c_ulong, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomEnable = _rpythonic_function_(		"dGeomEnable", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomDisable = _rpythonic_function_(		"dGeomDisable", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomIsEnabled = _rpythonic_function_(		"dGeomIsEnabled", ctypes.c_int, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomSetOffsetPosition = _rpythonic_function_(		"dGeomSetOffsetPosition", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dGeomSetOffsetRotation = _rpythonic_function_(		"dGeomSetOffsetRotation", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("R",		( ctypes.c_double * 12 )),] )

dGeomSetOffsetQuaternion = _rpythonic_function_(		"dGeomSetOffsetQuaternion", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("Q",		( ctypes.c_double * 4 )),] )

dGeomSetOffsetWorldPosition = _rpythonic_function_(		"dGeomSetOffsetWorldPosition", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dGeomSetOffsetWorldRotation = _rpythonic_function_(		"dGeomSetOffsetWorldRotation", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("R",		( ctypes.c_double * 12 )),] )

dGeomSetOffsetWorldQuaternion = _rpythonic_function_(		"dGeomSetOffsetWorldQuaternion", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("none",		( ctypes.c_double * 4 )),] )

dGeomClearOffset = _rpythonic_function_(		"dGeomClearOffset", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomIsOffset = _rpythonic_function_(		"dGeomIsOffset", ctypes.c_int, [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomGetOffsetPosition = _rpythonic_function_(		"dGeomGetOffsetPosition", ctypes.POINTER(ctypes.c_double), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomCopyOffsetPosition = _rpythonic_function_(		"dGeomCopyOffsetPosition", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("pos",		( ctypes.c_double * 4 )),] )

dGeomGetOffsetRotation = _rpythonic_function_(		"dGeomGetOffsetRotation", ctypes.POINTER(ctypes.c_double), [
	("geom",		ctypes.POINTER(dxGeom)),] )

dGeomCopyOffsetRotation = _rpythonic_function_(		"dGeomCopyOffsetRotation", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("R",		( ctypes.c_double * 12 )),] )

dGeomGetOffsetQuaternion = _rpythonic_function_(		"dGeomGetOffsetQuaternion", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("result",		( ctypes.c_double * 4 )),] )

dCollide = _rpythonic_function_(		"dCollide", ctypes.c_int, [
	("o1",		ctypes.POINTER(dxGeom)),
	("o2",		ctypes.POINTER(dxGeom)),
	("flags",		ctypes.c_int),
	("contact",		ctypes.POINTER(dContactGeom)),
	("skip",		ctypes.c_int),] )

dSpaceCollide = _rpythonic_function_(		"dSpaceCollide", ctypes.c_void_p, [
	("space",		ctypes.POINTER(dxSpace)),
	("data",		ctypes.POINTER(ctypes.c_void_p)),
	("callback",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),)),] )

dSpaceCollide2 = _rpythonic_function_(		"dSpaceCollide2", ctypes.c_void_p, [
	("space1",		ctypes.POINTER(dxGeom)),
	("space2",		ctypes.POINTER(dxGeom)),
	("data",		ctypes.POINTER(ctypes.c_void_p)),
	("callback",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),)),] )

dCreateSphere = _rpythonic_function_(		"dCreateSphere", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("radius",		ctypes.c_double),] )

dGeomSphereSetRadius = _rpythonic_function_(		"dGeomSphereSetRadius", ctypes.c_void_p, [
	("sphere",		ctypes.POINTER(dxGeom)),
	("radius",		ctypes.c_double),] )

dGeomSphereGetRadius = _rpythonic_function_(		"dGeomSphereGetRadius", ctypes.c_double, [
	("sphere",		ctypes.POINTER(dxGeom)),] )

dGeomSpherePointDepth = _rpythonic_function_(		"dGeomSpherePointDepth", ctypes.c_double, [
	("sphere",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dCreateConvex = _rpythonic_function_(		"dCreateConvex", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("_planes",		ctypes.POINTER(ctypes.c_double)),
	("_planecount",		ctypes.c_uint),
	("_points",		ctypes.POINTER(ctypes.c_double)),
	("_pointcount",		ctypes.c_uint),
	("_polygons",		ctypes.POINTER(ctypes.c_uint)),] )

dGeomSetConvex = _rpythonic_function_(		"dGeomSetConvex", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("_planes",		ctypes.POINTER(ctypes.c_double)),
	("_count",		ctypes.c_uint),
	("_points",		ctypes.POINTER(ctypes.c_double)),
	("_pointcount",		ctypes.c_uint),
	("_polygons",		ctypes.POINTER(ctypes.c_uint)),] )

dCreateBox = _rpythonic_function_(		"dCreateBox", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("lx",		ctypes.c_double),
	("ly",		ctypes.c_double),
	("lz",		ctypes.c_double),] )

dGeomBoxSetLengths = _rpythonic_function_(		"dGeomBoxSetLengths", ctypes.c_void_p, [
	("box",		ctypes.POINTER(dxGeom)),
	("lx",		ctypes.c_double),
	("ly",		ctypes.c_double),
	("lz",		ctypes.c_double),] )

dGeomBoxGetLengths = _rpythonic_function_(		"dGeomBoxGetLengths", ctypes.c_void_p, [
	("box",		ctypes.POINTER(dxGeom)),
	("result",		( ctypes.c_double * 4 )),] )

dGeomBoxPointDepth = _rpythonic_function_(		"dGeomBoxPointDepth", ctypes.c_double, [
	("box",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dCreatePlane = _rpythonic_function_(		"dCreatePlane", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("a",		ctypes.c_double),
	("b",		ctypes.c_double),
	("c",		ctypes.c_double),
	("d",		ctypes.c_double),] )

dGeomPlaneSetParams = _rpythonic_function_(		"dGeomPlaneSetParams", ctypes.c_void_p, [
	("plane",		ctypes.POINTER(dxGeom)),
	("a",		ctypes.c_double),
	("b",		ctypes.c_double),
	("c",		ctypes.c_double),
	("d",		ctypes.c_double),] )

dGeomPlaneGetParams = _rpythonic_function_(		"dGeomPlaneGetParams", ctypes.c_void_p, [
	("plane",		ctypes.POINTER(dxGeom)),
	("result",		( ctypes.c_double * 4 )),] )

dGeomPlanePointDepth = _rpythonic_function_(		"dGeomPlanePointDepth", ctypes.c_double, [
	("plane",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dCreateCapsule = _rpythonic_function_(		"dCreateCapsule", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dGeomCapsuleSetParams = _rpythonic_function_(		"dGeomCapsuleSetParams", ctypes.c_void_p, [
	("ccylinder",		ctypes.POINTER(dxGeom)),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dGeomCapsuleGetParams = _rpythonic_function_(		"dGeomCapsuleGetParams", ctypes.c_void_p, [
	("ccylinder",		ctypes.POINTER(dxGeom)),
	("radius",		ctypes.POINTER(ctypes.c_double)),
	("length",		ctypes.POINTER(ctypes.c_double)),] )

dGeomCapsulePointDepth = _rpythonic_function_(		"dGeomCapsulePointDepth", ctypes.c_double, [
	("ccylinder",		ctypes.POINTER(dxGeom)),
	("x",		ctypes.c_double),
	("y",		ctypes.c_double),
	("z",		ctypes.c_double),] )

dCreateCylinder = _rpythonic_function_(		"dCreateCylinder", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dGeomCylinderSetParams = _rpythonic_function_(		"dGeomCylinderSetParams", ctypes.c_void_p, [
	("cylinder",		ctypes.POINTER(dxGeom)),
	("radius",		ctypes.c_double),
	("length",		ctypes.c_double),] )

dGeomCylinderGetParams = _rpythonic_function_(		"dGeomCylinderGetParams", ctypes.c_void_p, [
	("cylinder",		ctypes.POINTER(dxGeom)),
	("radius",		ctypes.POINTER(ctypes.c_double)),
	("length",		ctypes.POINTER(ctypes.c_double)),] )

dCreateRay = _rpythonic_function_(		"dCreateRay", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("length",		ctypes.c_double),] )

dGeomRaySetLength = _rpythonic_function_(		"dGeomRaySetLength", ctypes.c_void_p, [
	("ray",		ctypes.POINTER(dxGeom)),
	("length",		ctypes.c_double),] )

dGeomRayGetLength = _rpythonic_function_(		"dGeomRayGetLength", ctypes.c_double, [
	("ray",		ctypes.POINTER(dxGeom)),] )

dGeomRaySet = _rpythonic_function_(		"dGeomRaySet", ctypes.c_void_p, [
	("ray",		ctypes.POINTER(dxGeom)),
	("px",		ctypes.c_double),
	("py",		ctypes.c_double),
	("pz",		ctypes.c_double),
	("dx",		ctypes.c_double),
	("dy",		ctypes.c_double),
	("dz",		ctypes.c_double),] )

dGeomRayGet = _rpythonic_function_(		"dGeomRayGet", ctypes.c_void_p, [
	("ray",		ctypes.POINTER(dxGeom)),
	("start",		( ctypes.c_double * 4 )),
	("dir",		( ctypes.c_double * 4 )),] )

dGeomRaySetParams = _rpythonic_function_(		"dGeomRaySetParams", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("FirstContact",		ctypes.c_int),
	("BackfaceCull",		ctypes.c_int),] )

dGeomRayGetParams = _rpythonic_function_(		"dGeomRayGetParams", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("FirstContact",		ctypes.POINTER(ctypes.c_int)),
	("BackfaceCull",		ctypes.POINTER(ctypes.c_int)),] )

dGeomRaySetClosestHit = _rpythonic_function_(		"dGeomRaySetClosestHit", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("closestHit",		ctypes.c_int),] )

dGeomRayGetClosestHit = _rpythonic_function_(		"dGeomRayGetClosestHit", ctypes.c_int, [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshDataCreate = _rpythonic_function_(		"dGeomTriMeshDataCreate", ctypes.POINTER(ctypes.c_void_p), [] )

dGeomTriMeshDataDestroy = _rpythonic_function_(		"dGeomTriMeshDataDestroy", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),] )

dGeomTriMeshDataSet = _rpythonic_function_(		"dGeomTriMeshDataSet", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("data_id",		ctypes.c_int),
	("in_data",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomTriMeshDataGet = _rpythonic_function_(		"dGeomTriMeshDataGet", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("data_id",		ctypes.c_int),] )

dGeomTriMeshSetLastTransform = _rpythonic_function_(		"dGeomTriMeshSetLastTransform", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("last_trans",		( ctypes.c_double * 16 )),] )

dGeomTriMeshGetLastTransform = _rpythonic_function_(		"dGeomTriMeshGetLastTransform", ctypes.POINTER(ctypes.c_double), [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshDataBuildSingle = _rpythonic_function_(		"dGeomTriMeshDataBuildSingle", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_void_p)),
	("VertexStride",		ctypes.c_int),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_void_p)),
	("IndexCount",		ctypes.c_int),
	("TriStride",		ctypes.c_int),] )

dGeomTriMeshDataBuildSingle1 = _rpythonic_function_(		"dGeomTriMeshDataBuildSingle1", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_void_p)),
	("VertexStride",		ctypes.c_int),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_void_p)),
	("IndexCount",		ctypes.c_int),
	("TriStride",		ctypes.c_int),
	("Normals",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomTriMeshDataBuildDouble = _rpythonic_function_(		"dGeomTriMeshDataBuildDouble", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_void_p)),
	("VertexStride",		ctypes.c_int),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_void_p)),
	("IndexCount",		ctypes.c_int),
	("TriStride",		ctypes.c_int),] )

dGeomTriMeshDataBuildDouble1 = _rpythonic_function_(		"dGeomTriMeshDataBuildDouble1", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_void_p)),
	("VertexStride",		ctypes.c_int),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_void_p)),
	("IndexCount",		ctypes.c_int),
	("TriStride",		ctypes.c_int),
	("Normals",		ctypes.POINTER(ctypes.c_void_p)),] )

dGeomTriMeshDataBuildSimple = _rpythonic_function_(		"dGeomTriMeshDataBuildSimple", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_double)),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_uint)),
	("IndexCount",		ctypes.c_int),] )

dGeomTriMeshDataBuildSimple1 = _rpythonic_function_(		"dGeomTriMeshDataBuildSimple1", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("Vertices",		ctypes.POINTER(ctypes.c_double)),
	("VertexCount",		ctypes.c_int),
	("Indices",		ctypes.POINTER(ctypes.c_uint)),
	("IndexCount",		ctypes.c_int),
	("Normals",		ctypes.POINTER(ctypes.c_int)),] )

dGeomTriMeshDataPreprocess = _rpythonic_function_(		"dGeomTriMeshDataPreprocess", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),] )

dGeomTriMeshDataGetBuffer = _rpythonic_function_(		"dGeomTriMeshDataGetBuffer", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("buf",		ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte))),
	("bufLen",		ctypes.POINTER(ctypes.c_int)),] )

dGeomTriMeshDataSetBuffer = _rpythonic_function_(		"dGeomTriMeshDataSetBuffer", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),
	("buf",		ctypes.POINTER(ctypes.c_ubyte)),] )

dTriCallback = _rpythonic_function_(		"dTriCallback", ctypes.c_int, [
	("TriMesh",		ctypes.POINTER(dxGeom)),
	("RefObject",		ctypes.POINTER(dxGeom)),
	("TriangleIndex",		ctypes.c_int),] )

dGeomTriMeshSetCallback = _rpythonic_function_(		"dGeomTriMeshSetCallback", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Callback",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,)),] )

dGeomTriMeshGetCallback = _rpythonic_function_(		"dGeomTriMeshGetCallback", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,), [
	("g",		ctypes.POINTER(dxGeom)),] )

dTriArrayCallback = _rpythonic_function_(		"dTriArrayCallback", ctypes.c_void_p, [
	("TriMesh",		ctypes.POINTER(dxGeom)),
	("RefObject",		ctypes.POINTER(dxGeom)),
	("TriIndices",		ctypes.POINTER(ctypes.c_int)),
	("TriCount",		ctypes.c_int),] )

dGeomTriMeshSetArrayCallback = _rpythonic_function_(		"dGeomTriMeshSetArrayCallback", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("ArrayCallback",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.POINTER(ctypes.c_int),ctypes.c_int,)),] )

dGeomTriMeshGetArrayCallback = _rpythonic_function_(		"dGeomTriMeshGetArrayCallback", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.POINTER(ctypes.c_int),ctypes.c_int,), [
	("g",		ctypes.POINTER(dxGeom)),] )

dTriRayCallback = _rpythonic_function_(		"dTriRayCallback", ctypes.c_int, [
	("TriMesh",		ctypes.POINTER(dxGeom)),
	("Ray",		ctypes.POINTER(dxGeom)),
	("TriangleIndex",		ctypes.c_int),
	("u",		ctypes.c_double),
	("v",		ctypes.c_double),] )

dGeomTriMeshSetRayCallback = _rpythonic_function_(		"dGeomTriMeshSetRayCallback", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Callback",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_double,ctypes.c_double,)),] )

dGeomTriMeshGetRayCallback = _rpythonic_function_(		"dGeomTriMeshGetRayCallback", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_double,ctypes.c_double,), [
	("g",		ctypes.POINTER(dxGeom)),] )

dTriTriMergeCallback = _rpythonic_function_(		"dTriTriMergeCallback", ctypes.c_int, [
	("TriMesh",		ctypes.POINTER(dxGeom)),
	("FirstTriangleIndex",		ctypes.c_int),
	("SecondTriangleIndex",		ctypes.c_int),] )

dGeomTriMeshSetTriMergeCallback = _rpythonic_function_(		"dGeomTriMeshSetTriMergeCallback", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Callback",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_int,)),] )

dGeomTriMeshGetTriMergeCallback = _rpythonic_function_(		"dGeomTriMeshGetTriMergeCallback", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_int,), [
	("g",		ctypes.POINTER(dxGeom)),] )

dCreateTriMesh = _rpythonic_function_(		"dCreateTriMesh", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("Data",		ctypes.POINTER(dxTriMeshData)),
	("Callback",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,)),
	("ArrayCallback",		ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.POINTER(ctypes.c_int),ctypes.c_int,)),
	("RayCallback",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.c_double,ctypes.c_double,)),] )

dGeomTriMeshSetData = _rpythonic_function_(		"dGeomTriMeshSetData", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Data",		ctypes.POINTER(dxTriMeshData)),] )

dGeomTriMeshGetData = _rpythonic_function_(		"dGeomTriMeshGetData", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshEnableTC = _rpythonic_function_(		"dGeomTriMeshEnableTC", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("geomClass",		ctypes.c_int),
	("enable",		ctypes.c_int),] )

dGeomTriMeshIsTCEnabled = _rpythonic_function_(		"dGeomTriMeshIsTCEnabled", ctypes.c_int, [
	("g",		ctypes.POINTER(dxGeom)),
	("geomClass",		ctypes.c_int),] )

dGeomTriMeshClearTCCache = _rpythonic_function_(		"dGeomTriMeshClearTCCache", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshGetTriMeshDataID = _rpythonic_function_(		"dGeomTriMeshGetTriMeshDataID", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshGetTriangle = _rpythonic_function_(		"dGeomTriMeshGetTriangle", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Index",		ctypes.c_int),
	("v0",		ctypes.POINTER(( ctypes.c_double * 4 ))),
	("v1",		ctypes.POINTER(( ctypes.c_double * 4 ))),
	("v2",		ctypes.POINTER(( ctypes.c_double * 4 ))),] )

dGeomTriMeshGetPoint = _rpythonic_function_(		"dGeomTriMeshGetPoint", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("Index",		ctypes.c_int),
	("u",		ctypes.c_double),
	("v",		ctypes.c_double),
	("Out",		( ctypes.c_double * 4 )),] )

dGeomTriMeshGetTriangleCount = _rpythonic_function_(		"dGeomTriMeshGetTriangleCount", ctypes.c_int, [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTriMeshDataUpdate = _rpythonic_function_(		"dGeomTriMeshDataUpdate", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxTriMeshData)),] )

dCreateGeomTransform = _rpythonic_function_(		"dCreateGeomTransform", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),] )

dGeomTransformSetGeom = _rpythonic_function_(		"dGeomTransformSetGeom", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("obj",		ctypes.POINTER(dxGeom)),] )

dGeomTransformGetGeom = _rpythonic_function_(		"dGeomTransformGetGeom", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTransformSetCleanup = _rpythonic_function_(		"dGeomTransformSetCleanup", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("mode",		ctypes.c_int),] )

dGeomTransformGetCleanup = _rpythonic_function_(		"dGeomTransformGetCleanup", ctypes.c_int, [
	("g",		ctypes.POINTER(dxGeom)),] )

dGeomTransformSetInfo = _rpythonic_function_(		"dGeomTransformSetInfo", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("mode",		ctypes.c_int),] )

dGeomTransformGetInfo = _rpythonic_function_(		"dGeomTransformGetInfo", ctypes.c_int, [
	("g",		ctypes.POINTER(dxGeom)),] )

dHeightfieldGetHeight = _rpythonic_function_(		"dHeightfieldGetHeight", ctypes.c_double, [
	("p_user_data",		ctypes.POINTER(ctypes.c_void_p)),
	("x",		ctypes.c_int),
	("z",		ctypes.c_int),] )

dCreateHeightfield = _rpythonic_function_(		"dCreateHeightfield", ctypes.POINTER(ctypes.c_void_p), [
	("space",		ctypes.POINTER(dxSpace)),
	("data",		ctypes.POINTER(dxHeightfieldData)),
	("bPlaceable",		ctypes.c_int),] )

dGeomHeightfieldDataCreate = _rpythonic_function_(		"dGeomHeightfieldDataCreate", ctypes.POINTER(ctypes.c_void_p), [] )

dGeomHeightfieldDataDestroy = _rpythonic_function_(		"dGeomHeightfieldDataDestroy", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),] )

dGeomHeightfieldDataBuildCallback = _rpythonic_function_(		"dGeomHeightfieldDataBuildCallback", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("pUserData",		ctypes.POINTER(ctypes.c_void_p)),
	("pCallback",		ctypes.CFUNCTYPE(ctypes.c_double, ctypes.POINTER(ctypes.c_void_p),ctypes.c_int,ctypes.c_int,)),
	("width",		ctypes.c_double),
	("depth",		ctypes.c_double),
	("widthSamples",		ctypes.c_int),
	("depthSamples",		ctypes.c_int),
	("scale",		ctypes.c_double),
	("offset",		ctypes.c_double),
	("thickness",		ctypes.c_double),
	("bWrap",		ctypes.c_int),] )

dGeomHeightfieldDataBuildByte = _rpythonic_function_(		"dGeomHeightfieldDataBuildByte", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("pHeightData",		ctypes.POINTER(ctypes.c_ubyte)),
	("bCopyHeightData",		ctypes.c_int),
	("width",		ctypes.c_double),
	("depth",		ctypes.c_double),
	("widthSamples",		ctypes.c_int),
	("depthSamples",		ctypes.c_int),
	("scale",		ctypes.c_double),
	("offset",		ctypes.c_double),
	("thickness",		ctypes.c_double),
	("bWrap",		ctypes.c_int),] )

dGeomHeightfieldDataBuildShort = _rpythonic_function_(		"dGeomHeightfieldDataBuildShort", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("pHeightData",		ctypes.POINTER(ctypes.c_short)),
	("bCopyHeightData",		ctypes.c_int),
	("width",		ctypes.c_double),
	("depth",		ctypes.c_double),
	("widthSamples",		ctypes.c_int),
	("depthSamples",		ctypes.c_int),
	("scale",		ctypes.c_double),
	("offset",		ctypes.c_double),
	("thickness",		ctypes.c_double),
	("bWrap",		ctypes.c_int),] )

dGeomHeightfieldDataBuildSingle = _rpythonic_function_(		"dGeomHeightfieldDataBuildSingle", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("pHeightData",		ctypes.POINTER(ctypes.c_float)),
	("bCopyHeightData",		ctypes.c_int),
	("width",		ctypes.c_double),
	("depth",		ctypes.c_double),
	("widthSamples",		ctypes.c_int),
	("depthSamples",		ctypes.c_int),
	("scale",		ctypes.c_double),
	("offset",		ctypes.c_double),
	("thickness",		ctypes.c_double),
	("bWrap",		ctypes.c_int),] )

dGeomHeightfieldDataBuildDouble = _rpythonic_function_(		"dGeomHeightfieldDataBuildDouble", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("pHeightData",		ctypes.POINTER(ctypes.c_double)),
	("bCopyHeightData",		ctypes.c_int),
	("width",		ctypes.c_double),
	("depth",		ctypes.c_double),
	("widthSamples",		ctypes.c_int),
	("depthSamples",		ctypes.c_int),
	("scale",		ctypes.c_double),
	("offset",		ctypes.c_double),
	("thickness",		ctypes.c_double),
	("bWrap",		ctypes.c_int),] )

dGeomHeightfieldDataSetBounds = _rpythonic_function_(		"dGeomHeightfieldDataSetBounds", ctypes.c_void_p, [
	("d",		ctypes.POINTER(dxHeightfieldData)),
	("minHeight",		ctypes.c_double),
	("maxHeight",		ctypes.c_double),] )

dGeomHeightfieldSetHeightfieldData = _rpythonic_function_(		"dGeomHeightfieldSetHeightfieldData", ctypes.c_void_p, [
	("g",		ctypes.POINTER(dxGeom)),
	("d",		ctypes.POINTER(dxHeightfieldData)),] )

dGeomHeightfieldGetHeightfieldData = _rpythonic_function_(		"dGeomHeightfieldGetHeightfieldData", ctypes.POINTER(ctypes.c_void_p), [
	("g",		ctypes.POINTER(dxGeom)),] )

dClosestLineSegmentPoints = _rpythonic_function_(		"dClosestLineSegmentPoints", ctypes.c_void_p, [
	("a1",		( ctypes.c_double * 4 )),
	("a2",		( ctypes.c_double * 4 )),
	("b1",		( ctypes.c_double * 4 )),
	("b2",		( ctypes.c_double * 4 )),
	("cp1",		( ctypes.c_double * 4 )),
	("cp2",		( ctypes.c_double * 4 )),] )

dBoxTouchesBox = _rpythonic_function_(		"dBoxTouchesBox", ctypes.c_int, [
	("_p1",		( ctypes.c_double * 4 )),
	("R1",		( ctypes.c_double * 12 )),
	("side1",		( ctypes.c_double * 4 )),
	("_p2",		( ctypes.c_double * 4 )),
	("R2",		( ctypes.c_double * 12 )),
	("side2",		( ctypes.c_double * 4 )),] )

dBoxBox = _rpythonic_function_(		"dBoxBox", ctypes.c_int, [
	("p1",		( ctypes.c_double * 4 )),
	("R1",		( ctypes.c_double * 12 )),
	("side1",		( ctypes.c_double * 4 )),
	("p2",		( ctypes.c_double * 4 )),
	("R2",		( ctypes.c_double * 12 )),
	("side2",		( ctypes.c_double * 4 )),
	("normal",		( ctypes.c_double * 4 )),
	("depth",		ctypes.POINTER(ctypes.c_double)),
	("return_code",		ctypes.POINTER(ctypes.c_int)),
	("flags",		ctypes.c_int),
	("contact",		ctypes.POINTER(dContactGeom)),
	("skip",		ctypes.c_int),] )

dInfiniteAABB = _rpythonic_function_(		"dInfiniteAABB", ctypes.c_void_p, [
	("geom",		ctypes.POINTER(dxGeom)),
	("aabb",		( ctypes.c_double * 6 )),] )

dGetAABBFn = _rpythonic_function_(		"dGetAABBFn", ctypes.c_void_p, [
	("none",		ctypes.POINTER(ctypes.c_void_p)),
	("aabb",		( ctypes.c_double * 6 )),] )

dColliderFn = _rpythonic_function_(		"dColliderFn", ctypes.c_int, [
	("o1",		ctypes.POINTER(dxGeom)),
	("o2",		ctypes.POINTER(dxGeom)),
	("flags",		ctypes.c_int),
	("contact",		ctypes.POINTER(dContactGeom)),
	("skip",		ctypes.c_int),] )

dGetColliderFnFn = _rpythonic_function_(		"dGetColliderFnFn", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.POINTER(dContactGeom),ctypes.c_int,), [
	("num",		ctypes.c_int),] )

dGeomDtorFn = _rpythonic_function_(		"dGeomDtorFn", ctypes.c_void_p, [
	("o",		ctypes.POINTER(dxGeom)),] )

dAABBTestFn = _rpythonic_function_(		"dAABBTestFn", ctypes.c_int, [
	("o1",		ctypes.POINTER(dxGeom)),
	("o2",		ctypes.POINTER(dxGeom)),
	("aabb",		( ctypes.c_double * 6 )),] )

dCreateGeomClass = _rpythonic_function_(		"dCreateGeomClass", ctypes.c_int, [
	("classptr",		ctypes.POINTER(dGeomClass)),] )

dGeomGetClassData = _rpythonic_function_(		"dGeomGetClassData", ctypes.POINTER(ctypes.c_void_p), [
	("none",		ctypes.POINTER(ctypes.c_void_p)),] )

dCreateGeom = _rpythonic_function_(		"dCreateGeom", ctypes.POINTER(ctypes.c_void_p), [
	("classnum",		ctypes.c_int),] )

dSetColliderOverride = _rpythonic_function_(		"dSetColliderOverride", ctypes.c_void_p, [
	("i",		ctypes.c_int),
	("j",		ctypes.c_int),
	("fn",		ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(dxGeom),ctypes.POINTER(dxGeom),ctypes.c_int,ctypes.POINTER(dContactGeom),ctypes.c_int,)),] )

dWorldExportDIF = _rpythonic_function_(		"dWorldExportDIF", ctypes.c_void_p, [
	("w",		ctypes.POINTER(dxWorld)),
	("file",		ctypes.POINTER(_IO_FILE)),
	("world_name",		ctypes.POINTER(ctypes.c_char)),] )


for _failed in RPYTHONIC_WRAPPER_FUNCTIONS_FAILURES: globals().pop( _failed )
print( "C functions loaded: %s" %len(RPYTHONIC_WRAPPER_FUNCTIONS) )
print( "C functions failed: %s" %len(RPYTHONIC_WRAPPER_FUNCTIONS_FAILURES) )