/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkMultiBlockDataSetAlgorithmWrap.h"
#include "vtkExodusIIReaderWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkDataSetWrap.h"
#include "vtkFloatArrayWrap.h"
#include "vtkGraphWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkExodusIIReaderWrap::ptpl;

VtkExodusIIReaderWrap::VtkExodusIIReaderWrap()
{ }

VtkExodusIIReaderWrap::VtkExodusIIReaderWrap(vtkSmartPointer<vtkExodusIIReader> _native)
{ native = _native; }

VtkExodusIIReaderWrap::~VtkExodusIIReaderWrap()
{ }

void VtkExodusIIReaderWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkExodusIIReader").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("ExodusIIReader").ToLocalChecked(), ConstructorGetter);
}

void VtkExodusIIReaderWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkExodusIIReaderWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkMultiBlockDataSetAlgorithmWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkMultiBlockDataSetAlgorithmWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkExodusIIReaderWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AnimateModeShapesOff", AnimateModeShapesOff);
	Nan::SetPrototypeMethod(tpl, "animateModeShapesOff", AnimateModeShapesOff);

	Nan::SetPrototypeMethod(tpl, "AnimateModeShapesOn", AnimateModeShapesOn);
	Nan::SetPrototypeMethod(tpl, "animateModeShapesOn", AnimateModeShapesOn);

	Nan::SetPrototypeMethod(tpl, "ApplyDisplacementsOff", ApplyDisplacementsOff);
	Nan::SetPrototypeMethod(tpl, "applyDisplacementsOff", ApplyDisplacementsOff);

	Nan::SetPrototypeMethod(tpl, "ApplyDisplacementsOn", ApplyDisplacementsOn);
	Nan::SetPrototypeMethod(tpl, "applyDisplacementsOn", ApplyDisplacementsOn);

	Nan::SetPrototypeMethod(tpl, "CanReadFile", CanReadFile);
	Nan::SetPrototypeMethod(tpl, "canReadFile", CanReadFile);

	Nan::SetPrototypeMethod(tpl, "Dump", Dump);
	Nan::SetPrototypeMethod(tpl, "dump", Dump);

	Nan::SetPrototypeMethod(tpl, "GenerateFileIdArrayOff", GenerateFileIdArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateFileIdArrayOff", GenerateFileIdArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateFileIdArrayOn", GenerateFileIdArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateFileIdArrayOn", GenerateFileIdArrayOn);

	Nan::SetPrototypeMethod(tpl, "GenerateGlobalElementIdArrayOff", GenerateGlobalElementIdArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateGlobalElementIdArrayOff", GenerateGlobalElementIdArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateGlobalElementIdArrayOn", GenerateGlobalElementIdArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateGlobalElementIdArrayOn", GenerateGlobalElementIdArrayOn);

	Nan::SetPrototypeMethod(tpl, "GenerateGlobalNodeIdArrayOff", GenerateGlobalNodeIdArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateGlobalNodeIdArrayOff", GenerateGlobalNodeIdArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateGlobalNodeIdArrayOn", GenerateGlobalNodeIdArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateGlobalNodeIdArrayOn", GenerateGlobalNodeIdArrayOn);

	Nan::SetPrototypeMethod(tpl, "GenerateImplicitElementIdArrayOff", GenerateImplicitElementIdArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateImplicitElementIdArrayOff", GenerateImplicitElementIdArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateImplicitElementIdArrayOn", GenerateImplicitElementIdArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateImplicitElementIdArrayOn", GenerateImplicitElementIdArrayOn);

	Nan::SetPrototypeMethod(tpl, "GenerateImplicitNodeIdArrayOff", GenerateImplicitNodeIdArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateImplicitNodeIdArrayOff", GenerateImplicitNodeIdArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateImplicitNodeIdArrayOn", GenerateImplicitNodeIdArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateImplicitNodeIdArrayOn", GenerateImplicitNodeIdArrayOn);

	Nan::SetPrototypeMethod(tpl, "GenerateObjectIdCellArrayOff", GenerateObjectIdCellArrayOff);
	Nan::SetPrototypeMethod(tpl, "generateObjectIdCellArrayOff", GenerateObjectIdCellArrayOff);

	Nan::SetPrototypeMethod(tpl, "GenerateObjectIdCellArrayOn", GenerateObjectIdCellArrayOn);
	Nan::SetPrototypeMethod(tpl, "generateObjectIdCellArrayOn", GenerateObjectIdCellArrayOn);

	Nan::SetPrototypeMethod(tpl, "GetAnimateModeShapes", GetAnimateModeShapes);
	Nan::SetPrototypeMethod(tpl, "getAnimateModeShapes", GetAnimateModeShapes);

	Nan::SetPrototypeMethod(tpl, "GetApplyDisplacements", GetApplyDisplacements);
	Nan::SetPrototypeMethod(tpl, "getApplyDisplacements", GetApplyDisplacements);

	Nan::SetPrototypeMethod(tpl, "GetAssemblyArrayID", GetAssemblyArrayID);
	Nan::SetPrototypeMethod(tpl, "getAssemblyArrayID", GetAssemblyArrayID);

	Nan::SetPrototypeMethod(tpl, "GetAssemblyArrayName", GetAssemblyArrayName);
	Nan::SetPrototypeMethod(tpl, "getAssemblyArrayName", GetAssemblyArrayName);

	Nan::SetPrototypeMethod(tpl, "GetAssemblyArrayStatus", GetAssemblyArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getAssemblyArrayStatus", GetAssemblyArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetCacheSize", GetCacheSize);
	Nan::SetPrototypeMethod(tpl, "getCacheSize", GetCacheSize);

	Nan::SetPrototypeMethod(tpl, "GetDimensionality", GetDimensionality);
	Nan::SetPrototypeMethod(tpl, "getDimensionality", GetDimensionality);

	Nan::SetPrototypeMethod(tpl, "GetDisplacementMagnitude", GetDisplacementMagnitude);
	Nan::SetPrototypeMethod(tpl, "getDisplacementMagnitude", GetDisplacementMagnitude);

	Nan::SetPrototypeMethod(tpl, "GetDisplayType", GetDisplayType);
	Nan::SetPrototypeMethod(tpl, "getDisplayType", GetDisplayType);

	Nan::SetPrototypeMethod(tpl, "GetEdgeBlockArrayName", GetEdgeBlockArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeBlockArrayName", GetEdgeBlockArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeBlockArrayStatus", GetEdgeBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getEdgeBlockArrayStatus", GetEdgeBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetEdgeMapArrayName", GetEdgeMapArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeMapArrayName", GetEdgeMapArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeMapArrayStatus", GetEdgeMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getEdgeMapArrayStatus", GetEdgeMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetEdgeResultArrayName", GetEdgeResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeResultArrayName", GetEdgeResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeResultArrayStatus", GetEdgeResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getEdgeResultArrayStatus", GetEdgeResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetEdgeSetArrayName", GetEdgeSetArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeSetArrayName", GetEdgeSetArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeSetArrayStatus", GetEdgeSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getEdgeSetArrayStatus", GetEdgeSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetEdgeSetResultArrayName", GetEdgeSetResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getEdgeSetResultArrayName", GetEdgeSetResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetEdgeSetResultArrayStatus", GetEdgeSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getEdgeSetResultArrayStatus", GetEdgeSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetElementBlockArrayName", GetElementBlockArrayName);
	Nan::SetPrototypeMethod(tpl, "getElementBlockArrayName", GetElementBlockArrayName);

	Nan::SetPrototypeMethod(tpl, "GetElementBlockArrayStatus", GetElementBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getElementBlockArrayStatus", GetElementBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetElementMapArrayName", GetElementMapArrayName);
	Nan::SetPrototypeMethod(tpl, "getElementMapArrayName", GetElementMapArrayName);

	Nan::SetPrototypeMethod(tpl, "GetElementMapArrayStatus", GetElementMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getElementMapArrayStatus", GetElementMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetElementResultArrayName", GetElementResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getElementResultArrayName", GetElementResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetElementResultArrayStatus", GetElementResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getElementResultArrayStatus", GetElementResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetElementSetArrayName", GetElementSetArrayName);
	Nan::SetPrototypeMethod(tpl, "getElementSetArrayName", GetElementSetArrayName);

	Nan::SetPrototypeMethod(tpl, "GetElementSetArrayStatus", GetElementSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getElementSetArrayStatus", GetElementSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetElementSetResultArrayName", GetElementSetResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getElementSetResultArrayName", GetElementSetResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetElementSetResultArrayStatus", GetElementSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getElementSetResultArrayStatus", GetElementSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFaceBlockArrayName", GetFaceBlockArrayName);
	Nan::SetPrototypeMethod(tpl, "getFaceBlockArrayName", GetFaceBlockArrayName);

	Nan::SetPrototypeMethod(tpl, "GetFaceBlockArrayStatus", GetFaceBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getFaceBlockArrayStatus", GetFaceBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFaceMapArrayName", GetFaceMapArrayName);
	Nan::SetPrototypeMethod(tpl, "getFaceMapArrayName", GetFaceMapArrayName);

	Nan::SetPrototypeMethod(tpl, "GetFaceMapArrayStatus", GetFaceMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getFaceMapArrayStatus", GetFaceMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFaceResultArrayName", GetFaceResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getFaceResultArrayName", GetFaceResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetFaceResultArrayStatus", GetFaceResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getFaceResultArrayStatus", GetFaceResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFaceSetArrayName", GetFaceSetArrayName);
	Nan::SetPrototypeMethod(tpl, "getFaceSetArrayName", GetFaceSetArrayName);

	Nan::SetPrototypeMethod(tpl, "GetFaceSetArrayStatus", GetFaceSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getFaceSetArrayStatus", GetFaceSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFaceSetResultArrayName", GetFaceSetResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getFaceSetResultArrayName", GetFaceSetResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetFaceSetResultArrayStatus", GetFaceSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getFaceSetResultArrayStatus", GetFaceSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetFileId", GetFileId);
	Nan::SetPrototypeMethod(tpl, "getFileId", GetFileId);

	Nan::SetPrototypeMethod(tpl, "GetFileName", GetFileName);
	Nan::SetPrototypeMethod(tpl, "getFileName", GetFileName);

	Nan::SetPrototypeMethod(tpl, "GetGenerateFileIdArray", GetGenerateFileIdArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateFileIdArray", GetGenerateFileIdArray);

	Nan::SetPrototypeMethod(tpl, "GetGenerateGlobalElementIdArray", GetGenerateGlobalElementIdArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateGlobalElementIdArray", GetGenerateGlobalElementIdArray);

	Nan::SetPrototypeMethod(tpl, "GetGenerateGlobalNodeIdArray", GetGenerateGlobalNodeIdArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateGlobalNodeIdArray", GetGenerateGlobalNodeIdArray);

	Nan::SetPrototypeMethod(tpl, "GetGenerateImplicitElementIdArray", GetGenerateImplicitElementIdArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateImplicitElementIdArray", GetGenerateImplicitElementIdArray);

	Nan::SetPrototypeMethod(tpl, "GetGenerateImplicitNodeIdArray", GetGenerateImplicitNodeIdArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateImplicitNodeIdArray", GetGenerateImplicitNodeIdArray);

	Nan::SetPrototypeMethod(tpl, "GetGenerateObjectIdCellArray", GetGenerateObjectIdCellArray);
	Nan::SetPrototypeMethod(tpl, "getGenerateObjectIdCellArray", GetGenerateObjectIdCellArray);

	Nan::SetPrototypeMethod(tpl, "GetGlobalEdgeID", GetGlobalEdgeID);
	Nan::SetPrototypeMethod(tpl, "getGlobalEdgeID", GetGlobalEdgeID);

	Nan::SetPrototypeMethod(tpl, "GetGlobalEdgeIdArrayName", GetGlobalEdgeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getGlobalEdgeIdArrayName", GetGlobalEdgeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlobalElementID", GetGlobalElementID);
	Nan::SetPrototypeMethod(tpl, "getGlobalElementID", GetGlobalElementID);

	Nan::SetPrototypeMethod(tpl, "GetGlobalElementIdArrayName", GetGlobalElementIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getGlobalElementIdArrayName", GetGlobalElementIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlobalFaceID", GetGlobalFaceID);
	Nan::SetPrototypeMethod(tpl, "getGlobalFaceID", GetGlobalFaceID);

	Nan::SetPrototypeMethod(tpl, "GetGlobalFaceIdArrayName", GetGlobalFaceIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getGlobalFaceIdArrayName", GetGlobalFaceIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlobalNodeID", GetGlobalNodeID);
	Nan::SetPrototypeMethod(tpl, "getGlobalNodeID", GetGlobalNodeID);

	Nan::SetPrototypeMethod(tpl, "GetGlobalNodeIdArrayName", GetGlobalNodeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getGlobalNodeIdArrayName", GetGlobalNodeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlobalResultArrayName", GetGlobalResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getGlobalResultArrayName", GetGlobalResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetGlobalResultArrayStatus", GetGlobalResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getGlobalResultArrayStatus", GetGlobalResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetHasModeShapes", GetHasModeShapes);
	Nan::SetPrototypeMethod(tpl, "getHasModeShapes", GetHasModeShapes);

	Nan::SetPrototypeMethod(tpl, "GetHierarchyArrayName", GetHierarchyArrayName);
	Nan::SetPrototypeMethod(tpl, "getHierarchyArrayName", GetHierarchyArrayName);

	Nan::SetPrototypeMethod(tpl, "GetHierarchyArrayStatus", GetHierarchyArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getHierarchyArrayStatus", GetHierarchyArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetImplicitEdgeIdArrayName", GetImplicitEdgeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getImplicitEdgeIdArrayName", GetImplicitEdgeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetImplicitElementIdArrayName", GetImplicitElementIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getImplicitElementIdArrayName", GetImplicitElementIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetImplicitFaceIdArrayName", GetImplicitFaceIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getImplicitFaceIdArrayName", GetImplicitFaceIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetImplicitNodeIdArrayName", GetImplicitNodeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getImplicitNodeIdArrayName", GetImplicitNodeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetMaterialArrayID", GetMaterialArrayID);
	Nan::SetPrototypeMethod(tpl, "getMaterialArrayID", GetMaterialArrayID);

	Nan::SetPrototypeMethod(tpl, "GetMaterialArrayName", GetMaterialArrayName);
	Nan::SetPrototypeMethod(tpl, "getMaterialArrayName", GetMaterialArrayName);

	Nan::SetPrototypeMethod(tpl, "GetMaterialArrayStatus", GetMaterialArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getMaterialArrayStatus", GetMaterialArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetMaxNameLength", GetMaxNameLength);
	Nan::SetPrototypeMethod(tpl, "getMaxNameLength", GetMaxNameLength);

	Nan::SetPrototypeMethod(tpl, "GetModeShapeTime", GetModeShapeTime);
	Nan::SetPrototypeMethod(tpl, "getModeShapeTime", GetModeShapeTime);

	Nan::SetPrototypeMethod(tpl, "GetModeShapesRange", GetModeShapesRange);
	Nan::SetPrototypeMethod(tpl, "getModeShapesRange", GetModeShapesRange);

	Nan::SetPrototypeMethod(tpl, "GetNodeMapArrayName", GetNodeMapArrayName);
	Nan::SetPrototypeMethod(tpl, "getNodeMapArrayName", GetNodeMapArrayName);

	Nan::SetPrototypeMethod(tpl, "GetNodeMapArrayStatus", GetNodeMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getNodeMapArrayStatus", GetNodeMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetNodeSetArrayName", GetNodeSetArrayName);
	Nan::SetPrototypeMethod(tpl, "getNodeSetArrayName", GetNodeSetArrayName);

	Nan::SetPrototypeMethod(tpl, "GetNodeSetArrayStatus", GetNodeSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getNodeSetArrayStatus", GetNodeSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetNodeSetResultArrayName", GetNodeSetResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getNodeSetResultArrayName", GetNodeSetResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetNodeSetResultArrayStatus", GetNodeSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getNodeSetResultArrayStatus", GetNodeSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfAssemblyArrays", GetNumberOfAssemblyArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfAssemblyArrays", GetNumberOfAssemblyArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgeBlockArrays", GetNumberOfEdgeBlockArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgeBlockArrays", GetNumberOfEdgeBlockArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgeMapArrays", GetNumberOfEdgeMapArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgeMapArrays", GetNumberOfEdgeMapArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgeResultArrays", GetNumberOfEdgeResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgeResultArrays", GetNumberOfEdgeResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgeSetArrays", GetNumberOfEdgeSetArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgeSetArrays", GetNumberOfEdgeSetArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgeSetResultArrays", GetNumberOfEdgeSetResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgeSetResultArrays", GetNumberOfEdgeSetResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEdgesInFile", GetNumberOfEdgesInFile);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEdgesInFile", GetNumberOfEdgesInFile);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementBlockArrays", GetNumberOfElementBlockArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementBlockArrays", GetNumberOfElementBlockArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementMapArrays", GetNumberOfElementMapArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementMapArrays", GetNumberOfElementMapArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementResultArrays", GetNumberOfElementResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementResultArrays", GetNumberOfElementResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementSetArrays", GetNumberOfElementSetArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementSetArrays", GetNumberOfElementSetArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementSetResultArrays", GetNumberOfElementSetResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementSetResultArrays", GetNumberOfElementSetResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfElementsInFile", GetNumberOfElementsInFile);
	Nan::SetPrototypeMethod(tpl, "getNumberOfElementsInFile", GetNumberOfElementsInFile);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfEntriesInObject", GetNumberOfEntriesInObject);
	Nan::SetPrototypeMethod(tpl, "getNumberOfEntriesInObject", GetNumberOfEntriesInObject);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFaceBlockArrays", GetNumberOfFaceBlockArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFaceBlockArrays", GetNumberOfFaceBlockArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFaceMapArrays", GetNumberOfFaceMapArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFaceMapArrays", GetNumberOfFaceMapArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFaceResultArrays", GetNumberOfFaceResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFaceResultArrays", GetNumberOfFaceResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFaceSetArrays", GetNumberOfFaceSetArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFaceSetArrays", GetNumberOfFaceSetArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFaceSetResultArrays", GetNumberOfFaceSetResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFaceSetResultArrays", GetNumberOfFaceSetResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfFacesInFile", GetNumberOfFacesInFile);
	Nan::SetPrototypeMethod(tpl, "getNumberOfFacesInFile", GetNumberOfFacesInFile);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfGlobalResultArrays", GetNumberOfGlobalResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfGlobalResultArrays", GetNumberOfGlobalResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfHierarchyArrays", GetNumberOfHierarchyArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfHierarchyArrays", GetNumberOfHierarchyArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfMaterialArrays", GetNumberOfMaterialArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfMaterialArrays", GetNumberOfMaterialArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfNodeMapArrays", GetNumberOfNodeMapArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfNodeMapArrays", GetNumberOfNodeMapArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfNodeSetArrays", GetNumberOfNodeSetArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfNodeSetArrays", GetNumberOfNodeSetArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfNodeSetResultArrays", GetNumberOfNodeSetResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfNodeSetResultArrays", GetNumberOfNodeSetResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfNodes", GetNumberOfNodes);
	Nan::SetPrototypeMethod(tpl, "getNumberOfNodes", GetNumberOfNodes);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfNodesInFile", GetNumberOfNodesInFile);
	Nan::SetPrototypeMethod(tpl, "getNumberOfNodesInFile", GetNumberOfNodesInFile);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfObjectArrayComponents", GetNumberOfObjectArrayComponents);
	Nan::SetPrototypeMethod(tpl, "getNumberOfObjectArrayComponents", GetNumberOfObjectArrayComponents);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfObjectArrays", GetNumberOfObjectArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfObjectArrays", GetNumberOfObjectArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfObjectAttributes", GetNumberOfObjectAttributes);
	Nan::SetPrototypeMethod(tpl, "getNumberOfObjectAttributes", GetNumberOfObjectAttributes);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfObjects", GetNumberOfObjects);
	Nan::SetPrototypeMethod(tpl, "getNumberOfObjects", GetNumberOfObjects);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfPartArrays", GetNumberOfPartArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfPartArrays", GetNumberOfPartArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfPointResultArrays", GetNumberOfPointResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfPointResultArrays", GetNumberOfPointResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfSideSetArrays", GetNumberOfSideSetArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfSideSetArrays", GetNumberOfSideSetArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfSideSetResultArrays", GetNumberOfSideSetResultArrays);
	Nan::SetPrototypeMethod(tpl, "getNumberOfSideSetResultArrays", GetNumberOfSideSetResultArrays);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfTimeSteps", GetNumberOfTimeSteps);
	Nan::SetPrototypeMethod(tpl, "getNumberOfTimeSteps", GetNumberOfTimeSteps);

	Nan::SetPrototypeMethod(tpl, "GetObjectArrayIndex", GetObjectArrayIndex);
	Nan::SetPrototypeMethod(tpl, "getObjectArrayIndex", GetObjectArrayIndex);

	Nan::SetPrototypeMethod(tpl, "GetObjectArrayName", GetObjectArrayName);
	Nan::SetPrototypeMethod(tpl, "getObjectArrayName", GetObjectArrayName);

	Nan::SetPrototypeMethod(tpl, "GetObjectArrayStatus", GetObjectArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getObjectArrayStatus", GetObjectArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetObjectAttributeIndex", GetObjectAttributeIndex);
	Nan::SetPrototypeMethod(tpl, "getObjectAttributeIndex", GetObjectAttributeIndex);

	Nan::SetPrototypeMethod(tpl, "GetObjectAttributeName", GetObjectAttributeName);
	Nan::SetPrototypeMethod(tpl, "getObjectAttributeName", GetObjectAttributeName);

	Nan::SetPrototypeMethod(tpl, "GetObjectAttributeStatus", GetObjectAttributeStatus);
	Nan::SetPrototypeMethod(tpl, "getObjectAttributeStatus", GetObjectAttributeStatus);

	Nan::SetPrototypeMethod(tpl, "GetObjectId", GetObjectId);
	Nan::SetPrototypeMethod(tpl, "getObjectId", GetObjectId);

	Nan::SetPrototypeMethod(tpl, "GetObjectIdArrayName", GetObjectIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getObjectIdArrayName", GetObjectIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetObjectIndex", GetObjectIndex);
	Nan::SetPrototypeMethod(tpl, "getObjectIndex", GetObjectIndex);

	Nan::SetPrototypeMethod(tpl, "GetObjectName", GetObjectName);
	Nan::SetPrototypeMethod(tpl, "getObjectName", GetObjectName);

	Nan::SetPrototypeMethod(tpl, "GetObjectStatus", GetObjectStatus);
	Nan::SetPrototypeMethod(tpl, "getObjectStatus", GetObjectStatus);

	Nan::SetPrototypeMethod(tpl, "GetObjectTypeFromName", GetObjectTypeFromName);
	Nan::SetPrototypeMethod(tpl, "getObjectTypeFromName", GetObjectTypeFromName);

	Nan::SetPrototypeMethod(tpl, "GetObjectTypeName", GetObjectTypeName);
	Nan::SetPrototypeMethod(tpl, "getObjectTypeName", GetObjectTypeName);

	Nan::SetPrototypeMethod(tpl, "GetPartArrayID", GetPartArrayID);
	Nan::SetPrototypeMethod(tpl, "getPartArrayID", GetPartArrayID);

	Nan::SetPrototypeMethod(tpl, "GetPartArrayName", GetPartArrayName);
	Nan::SetPrototypeMethod(tpl, "getPartArrayName", GetPartArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPartArrayStatus", GetPartArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getPartArrayStatus", GetPartArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetPartBlockInfo", GetPartBlockInfo);
	Nan::SetPrototypeMethod(tpl, "getPartBlockInfo", GetPartBlockInfo);

	Nan::SetPrototypeMethod(tpl, "GetPedigreeEdgeIdArrayName", GetPedigreeEdgeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getPedigreeEdgeIdArrayName", GetPedigreeEdgeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPedigreeElementIdArrayName", GetPedigreeElementIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getPedigreeElementIdArrayName", GetPedigreeElementIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPedigreeFaceIdArrayName", GetPedigreeFaceIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getPedigreeFaceIdArrayName", GetPedigreeFaceIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPedigreeNodeIdArrayName", GetPedigreeNodeIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getPedigreeNodeIdArrayName", GetPedigreeNodeIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPointResultArrayName", GetPointResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getPointResultArrayName", GetPointResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetPointResultArrayStatus", GetPointResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getPointResultArrayStatus", GetPointResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetSIL", GetSIL);
	Nan::SetPrototypeMethod(tpl, "getSIL", GetSIL);

	Nan::SetPrototypeMethod(tpl, "GetSILUpdateStamp", GetSILUpdateStamp);
	Nan::SetPrototypeMethod(tpl, "getSILUpdateStamp", GetSILUpdateStamp);

	Nan::SetPrototypeMethod(tpl, "GetSideSetArrayName", GetSideSetArrayName);
	Nan::SetPrototypeMethod(tpl, "getSideSetArrayName", GetSideSetArrayName);

	Nan::SetPrototypeMethod(tpl, "GetSideSetArrayStatus", GetSideSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getSideSetArrayStatus", GetSideSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetSideSetResultArrayName", GetSideSetResultArrayName);
	Nan::SetPrototypeMethod(tpl, "getSideSetResultArrayName", GetSideSetResultArrayName);

	Nan::SetPrototypeMethod(tpl, "GetSideSetResultArrayStatus", GetSideSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "getSideSetResultArrayStatus", GetSideSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "GetSideSetSourceElementIdArrayName", GetSideSetSourceElementIdArrayName);
	Nan::SetPrototypeMethod(tpl, "getSideSetSourceElementIdArrayName", GetSideSetSourceElementIdArrayName);

	Nan::SetPrototypeMethod(tpl, "GetSideSetSourceElementSideArrayName", GetSideSetSourceElementSideArrayName);
	Nan::SetPrototypeMethod(tpl, "getSideSetSourceElementSideArrayName", GetSideSetSourceElementSideArrayName);

	Nan::SetPrototypeMethod(tpl, "GetSqueezePoints", GetSqueezePoints);
	Nan::SetPrototypeMethod(tpl, "getSqueezePoints", GetSqueezePoints);

	Nan::SetPrototypeMethod(tpl, "GetTimeSeriesData", GetTimeSeriesData);
	Nan::SetPrototypeMethod(tpl, "getTimeSeriesData", GetTimeSeriesData);

	Nan::SetPrototypeMethod(tpl, "GetTimeStep", GetTimeStep);
	Nan::SetPrototypeMethod(tpl, "getTimeStep", GetTimeStep);

	Nan::SetPrototypeMethod(tpl, "GetTimeStepRange", GetTimeStepRange);
	Nan::SetPrototypeMethod(tpl, "getTimeStepRange", GetTimeStepRange);

	Nan::SetPrototypeMethod(tpl, "GetTitle", GetTitle);
	Nan::SetPrototypeMethod(tpl, "getTitle", GetTitle);

	Nan::SetPrototypeMethod(tpl, "GetVariableID", GetVariableID);
	Nan::SetPrototypeMethod(tpl, "getVariableID", GetVariableID);

	Nan::SetPrototypeMethod(tpl, "GetXMLFileName", GetXMLFileName);
	Nan::SetPrototypeMethod(tpl, "getXMLFileName", GetXMLFileName);

	Nan::SetPrototypeMethod(tpl, "HasModeShapesOff", HasModeShapesOff);
	Nan::SetPrototypeMethod(tpl, "hasModeShapesOff", HasModeShapesOff);

	Nan::SetPrototypeMethod(tpl, "HasModeShapesOn", HasModeShapesOn);
	Nan::SetPrototypeMethod(tpl, "hasModeShapesOn", HasModeShapesOn);

	Nan::SetPrototypeMethod(tpl, "IsValidVariable", IsValidVariable);
	Nan::SetPrototypeMethod(tpl, "isValidVariable", IsValidVariable);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "Reset", Reset);
	Nan::SetPrototypeMethod(tpl, "reset", Reset);

	Nan::SetPrototypeMethod(tpl, "ResetCache", ResetCache);
	Nan::SetPrototypeMethod(tpl, "resetCache", ResetCache);

	Nan::SetPrototypeMethod(tpl, "ResetSettings", ResetSettings);
	Nan::SetPrototypeMethod(tpl, "resetSettings", ResetSettings);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetAllArrayStatus", SetAllArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setAllArrayStatus", SetAllArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetAnimateModeShapes", SetAnimateModeShapes);
	Nan::SetPrototypeMethod(tpl, "setAnimateModeShapes", SetAnimateModeShapes);

	Nan::SetPrototypeMethod(tpl, "SetApplyDisplacements", SetApplyDisplacements);
	Nan::SetPrototypeMethod(tpl, "setApplyDisplacements", SetApplyDisplacements);

	Nan::SetPrototypeMethod(tpl, "SetAssemblyArrayStatus", SetAssemblyArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setAssemblyArrayStatus", SetAssemblyArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetCacheSize", SetCacheSize);
	Nan::SetPrototypeMethod(tpl, "setCacheSize", SetCacheSize);

	Nan::SetPrototypeMethod(tpl, "SetDisplacementMagnitude", SetDisplacementMagnitude);
	Nan::SetPrototypeMethod(tpl, "setDisplacementMagnitude", SetDisplacementMagnitude);

	Nan::SetPrototypeMethod(tpl, "SetDisplayType", SetDisplayType);
	Nan::SetPrototypeMethod(tpl, "setDisplayType", SetDisplayType);

	Nan::SetPrototypeMethod(tpl, "SetEdgeBlockArrayStatus", SetEdgeBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setEdgeBlockArrayStatus", SetEdgeBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetEdgeMapArrayStatus", SetEdgeMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setEdgeMapArrayStatus", SetEdgeMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetEdgeResultArrayStatus", SetEdgeResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setEdgeResultArrayStatus", SetEdgeResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetEdgeSetArrayStatus", SetEdgeSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setEdgeSetArrayStatus", SetEdgeSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetEdgeSetResultArrayStatus", SetEdgeSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setEdgeSetResultArrayStatus", SetEdgeSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetElementBlockArrayStatus", SetElementBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setElementBlockArrayStatus", SetElementBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetElementMapArrayStatus", SetElementMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setElementMapArrayStatus", SetElementMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetElementResultArrayStatus", SetElementResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setElementResultArrayStatus", SetElementResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetElementSetArrayStatus", SetElementSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setElementSetArrayStatus", SetElementSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetElementSetResultArrayStatus", SetElementSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setElementSetResultArrayStatus", SetElementSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFaceBlockArrayStatus", SetFaceBlockArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setFaceBlockArrayStatus", SetFaceBlockArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFaceMapArrayStatus", SetFaceMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setFaceMapArrayStatus", SetFaceMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFaceResultArrayStatus", SetFaceResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setFaceResultArrayStatus", SetFaceResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFaceSetArrayStatus", SetFaceSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setFaceSetArrayStatus", SetFaceSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFaceSetResultArrayStatus", SetFaceSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setFaceSetResultArrayStatus", SetFaceSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetFileId", SetFileId);
	Nan::SetPrototypeMethod(tpl, "setFileId", SetFileId);

	Nan::SetPrototypeMethod(tpl, "SetFileName", SetFileName);
	Nan::SetPrototypeMethod(tpl, "setFileName", SetFileName);

	Nan::SetPrototypeMethod(tpl, "SetGenerateFileIdArray", SetGenerateFileIdArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateFileIdArray", SetGenerateFileIdArray);

	Nan::SetPrototypeMethod(tpl, "SetGenerateGlobalElementIdArray", SetGenerateGlobalElementIdArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateGlobalElementIdArray", SetGenerateGlobalElementIdArray);

	Nan::SetPrototypeMethod(tpl, "SetGenerateGlobalNodeIdArray", SetGenerateGlobalNodeIdArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateGlobalNodeIdArray", SetGenerateGlobalNodeIdArray);

	Nan::SetPrototypeMethod(tpl, "SetGenerateImplicitElementIdArray", SetGenerateImplicitElementIdArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateImplicitElementIdArray", SetGenerateImplicitElementIdArray);

	Nan::SetPrototypeMethod(tpl, "SetGenerateImplicitNodeIdArray", SetGenerateImplicitNodeIdArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateImplicitNodeIdArray", SetGenerateImplicitNodeIdArray);

	Nan::SetPrototypeMethod(tpl, "SetGenerateObjectIdCellArray", SetGenerateObjectIdCellArray);
	Nan::SetPrototypeMethod(tpl, "setGenerateObjectIdCellArray", SetGenerateObjectIdCellArray);

	Nan::SetPrototypeMethod(tpl, "SetGlobalResultArrayStatus", SetGlobalResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setGlobalResultArrayStatus", SetGlobalResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetHasModeShapes", SetHasModeShapes);
	Nan::SetPrototypeMethod(tpl, "setHasModeShapes", SetHasModeShapes);

	Nan::SetPrototypeMethod(tpl, "SetHierarchyArrayStatus", SetHierarchyArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setHierarchyArrayStatus", SetHierarchyArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetMaterialArrayStatus", SetMaterialArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setMaterialArrayStatus", SetMaterialArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetModeShape", SetModeShape);
	Nan::SetPrototypeMethod(tpl, "setModeShape", SetModeShape);

	Nan::SetPrototypeMethod(tpl, "SetModeShapeTime", SetModeShapeTime);
	Nan::SetPrototypeMethod(tpl, "setModeShapeTime", SetModeShapeTime);

	Nan::SetPrototypeMethod(tpl, "SetNodeMapArrayStatus", SetNodeMapArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setNodeMapArrayStatus", SetNodeMapArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetNodeSetArrayStatus", SetNodeSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setNodeSetArrayStatus", SetNodeSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetNodeSetResultArrayStatus", SetNodeSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setNodeSetResultArrayStatus", SetNodeSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetObjectArrayStatus", SetObjectArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setObjectArrayStatus", SetObjectArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetObjectAttributeStatus", SetObjectAttributeStatus);
	Nan::SetPrototypeMethod(tpl, "setObjectAttributeStatus", SetObjectAttributeStatus);

	Nan::SetPrototypeMethod(tpl, "SetObjectStatus", SetObjectStatus);
	Nan::SetPrototypeMethod(tpl, "setObjectStatus", SetObjectStatus);

	Nan::SetPrototypeMethod(tpl, "SetPartArrayStatus", SetPartArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setPartArrayStatus", SetPartArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetPointResultArrayStatus", SetPointResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setPointResultArrayStatus", SetPointResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetSideSetArrayStatus", SetSideSetArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setSideSetArrayStatus", SetSideSetArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetSideSetResultArrayStatus", SetSideSetResultArrayStatus);
	Nan::SetPrototypeMethod(tpl, "setSideSetResultArrayStatus", SetSideSetResultArrayStatus);

	Nan::SetPrototypeMethod(tpl, "SetSqueezePoints", SetSqueezePoints);
	Nan::SetPrototypeMethod(tpl, "setSqueezePoints", SetSqueezePoints);

	Nan::SetPrototypeMethod(tpl, "SetTimeStep", SetTimeStep);
	Nan::SetPrototypeMethod(tpl, "setTimeStep", SetTimeStep);

	Nan::SetPrototypeMethod(tpl, "SetXMLFileName", SetXMLFileName);
	Nan::SetPrototypeMethod(tpl, "setXMLFileName", SetXMLFileName);

#ifdef VTK_NODE_PLUS_VTKEXODUSIIREADERWRAP_INITPTPL
	VTK_NODE_PLUS_VTKEXODUSIIREADERWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkExodusIIReaderWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkExodusIIReader> native = vtkSmartPointer<vtkExodusIIReader>::New();
		VtkExodusIIReaderWrap* obj = new VtkExodusIIReaderWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkExodusIIReaderWrap::AnimateModeShapesOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AnimateModeShapesOff();
}

void VtkExodusIIReaderWrap::AnimateModeShapesOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AnimateModeShapesOn();
}

void VtkExodusIIReaderWrap::ApplyDisplacementsOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ApplyDisplacementsOff();
}

void VtkExodusIIReaderWrap::ApplyDisplacementsOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ApplyDisplacementsOn();
}

void VtkExodusIIReaderWrap::CanReadFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->CanReadFile(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::Dump(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Dump();
}

void VtkExodusIIReaderWrap::GenerateFileIdArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateFileIdArrayOff();
}

void VtkExodusIIReaderWrap::GenerateFileIdArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateFileIdArrayOn();
}

void VtkExodusIIReaderWrap::GenerateGlobalElementIdArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateGlobalElementIdArrayOff();
}

void VtkExodusIIReaderWrap::GenerateGlobalElementIdArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateGlobalElementIdArrayOn();
}

void VtkExodusIIReaderWrap::GenerateGlobalNodeIdArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateGlobalNodeIdArrayOff();
}

void VtkExodusIIReaderWrap::GenerateGlobalNodeIdArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateGlobalNodeIdArrayOn();
}

void VtkExodusIIReaderWrap::GenerateImplicitElementIdArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateImplicitElementIdArrayOff();
}

void VtkExodusIIReaderWrap::GenerateImplicitElementIdArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateImplicitElementIdArrayOn();
}

void VtkExodusIIReaderWrap::GenerateImplicitNodeIdArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateImplicitNodeIdArrayOff();
}

void VtkExodusIIReaderWrap::GenerateImplicitNodeIdArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateImplicitNodeIdArrayOn();
}

void VtkExodusIIReaderWrap::GenerateObjectIdCellArrayOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateObjectIdCellArrayOff();
}

void VtkExodusIIReaderWrap::GenerateObjectIdCellArrayOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GenerateObjectIdCellArrayOn();
}

void VtkExodusIIReaderWrap::GetAnimateModeShapes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAnimateModeShapes();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetApplyDisplacements(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetApplyDisplacements();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetAssemblyArrayID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssemblyArrayID(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetAssemblyArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssemblyArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetAssemblyArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssemblyArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssemblyArrayStatus(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetCacheSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCacheSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetDimensionality(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDimensionality();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetDisplacementMagnitude(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	float r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDisplacementMagnitude();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetDisplayType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDisplayType();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetEdgeBlockArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeBlockArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeBlockArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeMapArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeMapArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeMapArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeSetArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeSetArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeSetArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeSetResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeSetResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetEdgeSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetEdgeSetResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementBlockArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementBlockArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementBlockArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementMapArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementMapArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementMapArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementSetArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementSetArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementSetArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementSetResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementSetResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetElementSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetElementSetResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceBlockArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceBlockArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceBlockArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceMapArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceMapArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceMapArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceSetArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceSetArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceSetArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceSetResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceSetResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFaceSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetFaceSetResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetFileId(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFileId();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetFileName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFileName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetGenerateFileIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateFileIdArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGenerateGlobalElementIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateGlobalElementIdArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGenerateGlobalNodeIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateGlobalNodeIdArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGenerateImplicitElementIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateImplicitElementIdArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGenerateImplicitNodeIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateImplicitNodeIdArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGenerateObjectIdCellArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenerateObjectIdCellArray();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetGlobalEdgeID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetGlobalEdgeID(
					(vtkDataSet *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetGlobalEdgeID(
				(vtkDataSet *) a0->native.GetPointer(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetGlobalEdgeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlobalEdgeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetGlobalElementID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetGlobalElementID(
					(vtkDataSet *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetGlobalElementID(
				(vtkDataSet *) a0->native.GetPointer(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetGlobalElementIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlobalElementIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetGlobalFaceID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetGlobalFaceID(
					(vtkDataSet *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetGlobalFaceID(
				(vtkDataSet *) a0->native.GetPointer(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetGlobalFaceIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlobalFaceIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetGlobalNodeID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetGlobalNodeID(
					(vtkDataSet *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetGlobalNodeID(
				(vtkDataSet *) a0->native.GetPointer(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetGlobalNodeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlobalNodeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetGlobalResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetGlobalResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetGlobalResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetGlobalResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetHasModeShapes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHasModeShapes();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetHierarchyArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetHierarchyArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetHierarchyArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetHierarchyArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetHierarchyArrayStatus(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetImplicitEdgeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImplicitEdgeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetImplicitElementIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImplicitElementIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetImplicitFaceIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImplicitFaceIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetImplicitNodeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImplicitNodeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetMaterialArrayID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetMaterialArrayID(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetMaterialArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetMaterialArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetMaterialArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetMaterialArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetMaterialArrayStatus(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetMaxNameLength(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaxNameLength();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetModeShapeTime(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetModeShapeTime();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetModeShapesRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetModeShapesRange();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(int));
	Local<v8::Int32Array> at = v8::Int32Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(int));
	info.GetReturnValue().Set(at);
}

void VtkExodusIIReaderWrap::GetNodeMapArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeMapArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNodeMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeMapArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNodeSetArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeSetArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNodeSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeSetArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNodeSetResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeSetResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNodeSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNodeSetResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfAssemblyArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfAssemblyArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgeBlockArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgeBlockArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgeMapArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgeMapArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgeResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgeResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgeSetArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgeSetArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgeSetResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgeSetResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEdgesInFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfEdgesInFile();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementBlockArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementBlockArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementMapArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementMapArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementSetArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementSetArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementSetResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementSetResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfElementsInFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfElementsInFile();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfEntriesInObject(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetNumberOfEntriesInObject(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfFaceBlockArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFaceBlockArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfFaceMapArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFaceMapArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfFaceResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFaceResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfFaceSetArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFaceSetArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfFaceSetResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFaceSetResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfFacesInFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfFacesInFile();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfGlobalResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfGlobalResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfHierarchyArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfHierarchyArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfMaterialArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfMaterialArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfNodeMapArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfNodeMapArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfNodeSetArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfNodeSetArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfNodeSetResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfNodeSetResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfNodes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfNodes();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfNodesInFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfNodesInFile();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfObjectArrayComponents(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetNumberOfObjectArrayComponents(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfObjectArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNumberOfObjectArrays(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfObjectAttributes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetNumberOfObjectAttributes(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfObjects(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNumberOfObjects(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetNumberOfPartArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfPartArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfPointResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfPointResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfSideSetArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfSideSetArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfSideSetResultArrays(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfSideSetResultArrays();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetNumberOfTimeSteps(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfTimeSteps();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetObjectArrayIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectArrayIndex(
				info[0]->Int32Value(),
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			char const * r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectArrayName(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectArrayStatus(
				info[0]->Int32Value(),
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
		else if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectAttributeIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetObjectAttributeIndex(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					*a2
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectAttributeName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				char const * r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetObjectAttributeName(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectAttributeStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetObjectAttributeStatus(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					*a2
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
			else if(info.Length() > 2 && info[2]->IsInt32())
			{
				int r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetObjectAttributeStatus(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				info.GetReturnValue().Set(Nan::New(r));
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectId(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectId(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetObjectIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetObjectIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectIndex(
				info[0]->Int32Value(),
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
		else if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectIndex(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			char const * r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectName(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectStatus(
				info[0]->Int32Value(),
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
		else if(info.Length() > 1 && info[1]->IsInt32())
		{
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetObjectStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectTypeFromName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetObjectTypeFromName(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetObjectTypeName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetObjectTypeName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPartArrayID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPartArrayID(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPartArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPartArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPartArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPartArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPartArrayStatus(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPartBlockInfo(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPartBlockInfo(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPedigreeEdgeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPedigreeEdgeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetPedigreeElementIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPedigreeElementIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetPedigreeFaceIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPedigreeFaceIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetPedigreeNodeIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPedigreeNodeIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetPointResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPointResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetPointResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetPointResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetSIL(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	vtkGraph * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSIL();
	VtkGraphWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkGraphWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkGraphWrap *w = new VtkGraphWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkExodusIIReaderWrap::GetSILUpdateStamp(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSILUpdateStamp();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetSideSetArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSideSetArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetSideSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSideSetArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetSideSetResultArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSideSetResultArrayName(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetSideSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSideSetResultArrayStatus(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetSideSetSourceElementIdArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSideSetSourceElementIdArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetSideSetSourceElementSideArrayName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSideSetSourceElementSideArrayName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetSqueezePoints(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	bool r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSqueezePoints();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetTimeSeriesData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				if(info.Length() > 3 && info[3]->IsObject() && (Nan::New(VtkFloatArrayWrap::ptpl))->HasInstance(info[3]))
				{
					VtkFloatArrayWrap *a3 = ObjectWrap::Unwrap<VtkFloatArrayWrap>(info[3]->ToObject());
					int r;
					if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					r = native->GetTimeSeriesData(
						info[0]->Int32Value(),
						*a1,
						*a2,
						(vtkFloatArray *) a3->native.GetPointer()
					);
					info.GetReturnValue().Set(Nan::New(r));
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetTimeStep(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimeStep();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkExodusIIReaderWrap::GetTimeStepRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	int const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTimeStepRange();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(int));
	Local<v8::Int32Array> at = v8::Int32Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(int));
	info.GetReturnValue().Set(at);
}

void VtkExodusIIReaderWrap::GetTitle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTitle();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::GetVariableID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetVariableID(
				*a0,
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::GetXMLFileName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetXMLFileName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkExodusIIReaderWrap::HasModeShapesOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HasModeShapesOff();
}

void VtkExodusIIReaderWrap::HasModeShapesOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->HasModeShapesOn();
}

void VtkExodusIIReaderWrap::IsValidVariable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			int r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->IsValidVariable(
				*a0,
				*a1
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	vtkExodusIIReader * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkExodusIIReaderWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkExodusIIReaderWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkExodusIIReaderWrap *w = new VtkExodusIIReaderWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkExodusIIReaderWrap::Reset(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Reset();
}

void VtkExodusIIReaderWrap::ResetCache(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ResetCache();
}

void VtkExodusIIReaderWrap::ResetSettings(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ResetSettings();
}

void VtkExodusIIReaderWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkExodusIIReader * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkExodusIIReaderWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkExodusIIReaderWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkExodusIIReaderWrap *w = new VtkExodusIIReaderWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetAllArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetAllArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetAnimateModeShapes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetAnimateModeShapes(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetApplyDisplacements(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetApplyDisplacements(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetAssemblyArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetAssemblyArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetAssemblyArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetCacheSize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetCacheSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetDisplacementMagnitude(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetDisplacementMagnitude(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetDisplayType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetDisplayType(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetEdgeBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEdgeBlockArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetEdgeMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEdgeMapArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetEdgeResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEdgeResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetEdgeSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEdgeSetArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetEdgeSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetEdgeSetResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetElementBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetElementBlockArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetElementMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetElementMapArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetElementResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetElementResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetElementSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetElementSetArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetElementSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetElementSetResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFaceBlockArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFaceBlockArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFaceMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFaceMapArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFaceResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFaceResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFaceSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFaceSetArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFaceSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFaceSetResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFileId(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFileId(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetFileName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFileName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateFileIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateFileIdArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateGlobalElementIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateGlobalElementIdArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateGlobalNodeIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateGlobalNodeIdArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateImplicitElementIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateImplicitElementIdArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateImplicitNodeIdArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateImplicitNodeIdArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGenerateObjectIdCellArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenerateObjectIdCellArray(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetGlobalResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetGlobalResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetHasModeShapes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetHasModeShapes(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetHierarchyArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetHierarchyArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetHierarchyArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetMaterialArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetMaterialArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetMaterialArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetModeShape(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetModeShape(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetModeShapeTime(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetModeShapeTime(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetNodeMapArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetNodeMapArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetNodeSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetNodeSetArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetNodeSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetNodeSetResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetObjectArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetObjectArrayStatus(
					info[0]->Int32Value(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
		else if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetObjectArrayStatus(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetObjectAttributeStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				if(info.Length() > 3 && info[3]->IsInt32())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetObjectAttributeStatus(
						info[0]->Int32Value(),
						info[1]->Int32Value(),
						*a2,
						info[3]->Int32Value()
					);
					return;
				}
			}
			else if(info.Length() > 2 && info[2]->IsInt32())
			{
				if(info.Length() > 3 && info[3]->IsInt32())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetObjectAttributeStatus(
						info[0]->Int32Value(),
						info[1]->Int32Value(),
						info[2]->Int32Value(),
						info[3]->Int32Value()
					);
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetObjectStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetObjectStatus(
					info[0]->Int32Value(),
					*a1,
					info[2]->Int32Value()
				);
				return;
			}
		}
		else if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetObjectStatus(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetPartArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPartArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPartArrayStatus(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetPointResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetPointResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetSideSetArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetSideSetArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetSideSetResultArrayStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		if(info.Length() > 1 && info[1]->IsInt32())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetSideSetResultArrayStatus(
				*a0,
				info[1]->Int32Value()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetSqueezePoints(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsBoolean())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSqueezePoints(
			info[0]->BooleanValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetTimeStep(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTimeStep(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkExodusIIReaderWrap::SetXMLFileName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkExodusIIReaderWrap *wrapper = ObjectWrap::Unwrap<VtkExodusIIReaderWrap>(info.Holder());
	vtkExodusIIReader *native = (vtkExodusIIReader *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetXMLFileName(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}