SOP_GuideProcessCore.proto.h

Go to the documentation of this file.

/* Automagically Generated by generate_proto.py
 * Do not Edit
 */
#pragma once

#include <SOP/SOP_API.h>
#include <SOP/SOP_NodeVerb.h>
#include <SOP/SOP_GraphProxy.h>

#include <OP/OP_Utils.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NTStreamUtil.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringStream.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_EnvControl.h>
#include <SYS/SYS_Types.h>

class DEP_MicroNode;
namespace SOP_GuideProcessCoreEnums
{
    enum class Geotype
    {
        POLYGONS = 0,
        BARBS
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Geotype enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Geotype::POLYGONS: return "polygons"_sh;
        case Geotype::BARBS: return "barbs"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Grouptype
    {
        PRIMITIVE = 0,
        POINT,
        EDGE
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Grouptype enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Grouptype::PRIMITIVE: return "primitive"_sh;
        case Grouptype::POINT: return "point"_sh;
        case Grouptype::EDGE: return "edge"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Blendoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Blendoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Blendoverride::NONE: return "none"_sh;
        case Blendoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Blendoverride::SKINATTRIB: return "skinattrib"_sh;
        case Blendoverride::TEXTURE: return "texture"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Op
    {
        SETLENGTH = 0,
        BEND
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Op enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Op::SETLENGTH: return "setlength"_sh;
        case Op::BEND: return "bend"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_mode
    {
        SET = 0,
        MULTIPLY,
        ADD,
        SUBTRACT,
        SETMIN,
        SETMAX
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_mode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_mode::SET: return "set"_sh;
        case Setlength_mode::MULTIPLY: return "multiply"_sh;
        case Setlength_mode::ADD: return "add"_sh;
        case Setlength_mode::SUBTRACT: return "subtract"_sh;
        case Setlength_mode::SETMIN: return "setmin"_sh;
        case Setlength_mode::SETMAX: return "setmax"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_method
    {
        SCALE = 0,
        CUTEXTEND
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_method enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_method::SCALE: return "scale"_sh;
        case Setlength_method::CUTEXTEND: return "cutextend"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthoverride::NONE: return "none"_sh;
        case Setlength_lengthoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_lengthoverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_lengthoverride::TEXTURE: return "texture"_sh;
        case Setlength_lengthoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthuvmode::SKINUV: return "skinuv"_sh;
        case Setlength_lengthuvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_lengthuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthrandminoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthrandminoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthrandminoverride::NONE: return "none"_sh;
        case Setlength_lengthrandminoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_lengthrandminoverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_lengthrandminoverride::TEXTURE: return "texture"_sh;
        case Setlength_lengthrandminoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthrandminuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthrandminuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthrandminuvmode::SKINUV: return "skinuv"_sh;
        case Setlength_lengthrandminuvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_lengthrandminuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthrandmaxoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthrandmaxoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthrandmaxoverride::NONE: return "none"_sh;
        case Setlength_lengthrandmaxoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_lengthrandmaxoverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_lengthrandmaxoverride::TEXTURE: return "texture"_sh;
        case Setlength_lengthrandmaxoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_lengthrandmaxuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_lengthrandmaxuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_lengthrandmaxuvmode::SKINUV: return "skinuv"_sh;
        case Setlength_lengthrandmaxuvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_lengthrandmaxuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactoroverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactoroverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactoroverride::NONE: return "none"_sh;
        case Setlength_scalefactoroverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_scalefactoroverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_scalefactoroverride::TEXTURE: return "texture"_sh;
        case Setlength_scalefactoroverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactoruvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactoruvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactoruvmode::SKINUV: return "skinuv"_sh;
        case Setlength_scalefactoruvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_scalefactoruvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactorrandminoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactorrandminoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactorrandminoverride::NONE: return "none"_sh;
        case Setlength_scalefactorrandminoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_scalefactorrandminoverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_scalefactorrandminoverride::TEXTURE: return "texture"_sh;
        case Setlength_scalefactorrandminoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactorrandminuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactorrandminuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactorrandminuvmode::SKINUV: return "skinuv"_sh;
        case Setlength_scalefactorrandminuvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_scalefactorrandminuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactorrandmaxoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactorrandmaxoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactorrandmaxoverride::NONE: return "none"_sh;
        case Setlength_scalefactorrandmaxoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Setlength_scalefactorrandmaxoverride::SKINATTRIB: return "skinattrib"_sh;
        case Setlength_scalefactorrandmaxoverride::TEXTURE: return "texture"_sh;
        case Setlength_scalefactorrandmaxoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Setlength_scalefactorrandmaxuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Setlength_scalefactorrandmaxuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Setlength_scalefactorrandmaxuvmode::SKINUV: return "skinuv"_sh;
        case Setlength_scalefactorrandmaxuvmode::CURVEUV: return "curveuv"_sh;
        case Setlength_scalefactorrandmaxuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_axismode
    {
        ROOTDIR = 0,
        DIRCONSTANT,
        DIRCURVEATTRIB,
        DIRSKINATTRIB,
        AXISCONSTANT,
        AXISCURVEATTRIB,
        AXISSKINATTRIB
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_axismode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_axismode::ROOTDIR: return "rootdir"_sh;
        case Bend_axismode::DIRCONSTANT: return "dirconstant"_sh;
        case Bend_axismode::DIRCURVEATTRIB: return "dircurveattrib"_sh;
        case Bend_axismode::DIRSKINATTRIB: return "dirskinattrib"_sh;
        case Bend_axismode::AXISCONSTANT: return "axisconstant"_sh;
        case Bend_axismode::AXISCURVEATTRIB: return "axiscurveattrib"_sh;
        case Bend_axismode::AXISSKINATTRIB: return "axisskinattrib"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_dirtoaxis
    {
        SKINNORMAL = 0,
        ROOTDIR,
        TANGENT
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_dirtoaxis enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_dirtoaxis::SKINNORMAL: return "skinnormal"_sh;
        case Bend_dirtoaxis::ROOTDIR: return "rootdir"_sh;
        case Bend_dirtoaxis::TANGENT: return "tangent"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_angleoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_angleoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_angleoverride::NONE: return "none"_sh;
        case Bend_angleoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Bend_angleoverride::SKINATTRIB: return "skinattrib"_sh;
        case Bend_angleoverride::TEXTURE: return "texture"_sh;
        case Bend_angleoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_angleuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_angleuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_angleuvmode::SKINUV: return "skinuv"_sh;
        case Bend_angleuvmode::CURVEUV: return "curveuv"_sh;
        case Bend_angleuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_anglerandoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_anglerandoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_anglerandoverride::NONE: return "none"_sh;
        case Bend_anglerandoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Bend_anglerandoverride::SKINATTRIB: return "skinattrib"_sh;
        case Bend_anglerandoverride::TEXTURE: return "texture"_sh;
        case Bend_anglerandoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_angleranduvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_angleranduvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_angleranduvmode::SKINUV: return "skinuv"_sh;
        case Bend_angleranduvmode::CURVEUV: return "curveuv"_sh;
        case Bend_angleranduvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_anglerandbiasoverride
    {
        NONE = 0,
        CURVEATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_anglerandbiasoverride enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_anglerandbiasoverride::NONE: return "none"_sh;
        case Bend_anglerandbiasoverride::CURVEATTRIB: return "curveattrib"_sh;
        case Bend_anglerandbiasoverride::SKINATTRIB: return "skinattrib"_sh;
        case Bend_anglerandbiasoverride::TEXTURE: return "texture"_sh;
        case Bend_anglerandbiasoverride::TEXTUREPRIM: return "textureprim"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Bend_anglerandbiasuvmode
    {
        SKINUV = 0,
        CURVEUV,
        FEATHERUV
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Bend_anglerandbiasuvmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Bend_anglerandbiasuvmode::SKINUV: return "skinuv"_sh;
        case Bend_anglerandbiasuvmode::CURVEUV: return "curveuv"_sh;
        case Bend_anglerandbiasuvmode::FEATHERUV: return "featheruv"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


class SOP_API SOP_GuideProcessCoreParms  : public SOP_NodeParms
{
public:
    static int version() { return 1; }

    SOP_GuideProcessCoreParms()
    {
        myGeotype = 0;
        myBarbside = 3;
        myUvattrib = "uv"_UTsh;
        myGrouptype = 0;
        myGroup = ""_UTsh;
        mySeed = 0;
        myVismasks = true;
        myBlend = 1;
        myBlendoverride = 0;
        myBlendcurveattrib = "mask"_UTsh;
        myBlendattrib = "mask"_UTsh;
        myBlendtexture = ""_UTsh;
        myOp = 0;
        mySetlength_mode = 0;
        mySetlength_method = 1;
        mySetlength_blend = 1;
        mySetlength_randomize = false;
        mySetlength_length = 0.1;
        mySetlength_lengthoverride = 0;
        mySetlength_lengthoptions = 0;
        mySetlength_lengthinrange = UT_Vector2D(0,1);
        mySetlength_lengthoutrange = UT_Vector2D(0,1);
        mySetlength_lengthremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_lengthcurveattrib = "length"_UTsh;
        mySetlength_lengthattrib = "length"_UTsh;
        mySetlength_lengthtexture = ""_UTsh;
        mySetlength_lengthtextureprim = "mask"_UTsh;
        mySetlength_lengthuvmode = 0;
        mySetlength_lengthrandmin = 0.1;
        mySetlength_lengthrandminoverride = 0;
        mySetlength_lengthrandminoptions = 0;
        mySetlength_lengthrandmininrange = UT_Vector2D(0,1);
        mySetlength_lengthrandminoutrange = UT_Vector2D(0,1);
        mySetlength_lengthrandminremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_lengthrandmincurveattrib = "minlength"_UTsh;
        mySetlength_lengthrandminattrib = "minlength"_UTsh;
        mySetlength_lengthrandmintexture = ""_UTsh;
        mySetlength_lengthrandmintextureprim = "mask"_UTsh;
        mySetlength_lengthrandminuvmode = 0;
        mySetlength_lengthrandmax = 0.2;
        mySetlength_lengthrandmaxoverride = 0;
        mySetlength_lengthrandmaxoptions = 0;
        mySetlength_lengthrandmaxinrange = UT_Vector2D(0,1);
        mySetlength_lengthrandmaxoutrange = UT_Vector2D(0,1);
        mySetlength_lengthrandmaxremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_lengthrandmaxcurveattrib = "maxlength"_UTsh;
        mySetlength_lengthrandmaxattrib = "maxlength"_UTsh;
        mySetlength_lengthrandmaxtexture = ""_UTsh;
        mySetlength_lengthrandmaxtextureprim = "mask"_UTsh;
        mySetlength_lengthrandmaxuvmode = 0;
        mySetlength_scalefactor = 1;
        mySetlength_scalefactoroverride = 0;
        mySetlength_scalefactoroptions = 0;
        mySetlength_scalefactorinrange = UT_Vector2D(0,1);
        mySetlength_scalefactoroutrange = UT_Vector2D(0,1);
        mySetlength_scalefactorremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_scalefactorcurveattrib = "scalefactor"_UTsh;
        mySetlength_scalefactorattrib = "scalefactor"_UTsh;
        mySetlength_scalefactortexture = ""_UTsh;
        mySetlength_scalefactortextureprim = "mask"_UTsh;
        mySetlength_scalefactoruvmode = 0;
        mySetlength_scalefactorrandmin = 1;
        mySetlength_scalefactorrandminoverride = 0;
        mySetlength_scalefactorrandminoptions = 0;
        mySetlength_scalefactorrandmininrange = UT_Vector2D(0,1);
        mySetlength_scalefactorrandminoutrange = UT_Vector2D(0,1);
        mySetlength_scalefactorrandminremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_scalefactorrandmincurveattrib = "scalefactormin"_UTsh;
        mySetlength_scalefactorrandminattrib = "scalefactormin"_UTsh;
        mySetlength_scalefactorrandmintexture = ""_UTsh;
        mySetlength_scalefactorrandmintextureprim = "mask"_UTsh;
        mySetlength_scalefactorrandminuvmode = 0;
        mySetlength_scalefactorrandmax = 1;
        mySetlength_scalefactorrandmaxoverride = 0;
        mySetlength_scalefactorrandmaxoptions = 0;
        mySetlength_scalefactorrandmaxinrange = UT_Vector2D(0,1);
        mySetlength_scalefactorrandmaxoutrange = UT_Vector2D(0,1);
        mySetlength_scalefactorrandmaxremapramp = UT_SharedPtr<UT_Ramp>(0);
        mySetlength_scalefactorrandmaxcurveattrib = "scalefactormax"_UTsh;
        mySetlength_scalefactorrandmaxattrib = "scalefactormax"_UTsh;
        mySetlength_scalefactorrandmaxtexture = ""_UTsh;
        mySetlength_scalefactorrandmaxtextureprim = "mask"_UTsh;
        mySetlength_scalefactorrandmaxuvmode = 0;
        mySetlength_cullzerolen = true;
        mySetlength_cullthreshold = 0.0001;
        myBend_blend = 1;
        myBend_axismode = 0;
        myBend_axis = UT_Vector3D(0,0,-1);
        myBend_axiscurveattrib = "bendaxis"_UTsh;
        myBend_axisskinattrib = "bendaxis"_UTsh;
        myBend_dir = UT_Vector3D(0,0,-1);
        myBend_dircurveattrib = "benddir"_UTsh;
        myBend_dirskinattrib = "benddir"_UTsh;
        myBend_dirtoaxis = 0;
        myBend_angle = 15;
        myBend_angleoverride = 0;
        myBend_angleoptions = 0;
        myBend_angleinrange = UT_Vector2D(0,1);
        myBend_angleoutrange = UT_Vector2D(0,1);
        myBend_anglemapramptobarbs = false;
        myBend_angleremapramp = UT_SharedPtr<UT_Ramp>(0);
        myBend_anglecurveattrib = "anglescale"_UTsh;
        myBend_angleattrib = "anglescale"_UTsh;
        myBend_angletexture = ""_UTsh;
        myBend_angletextureprim = "mask"_UTsh;
        myBend_angleuvmode = 0;
        myBend_anglerand = 0;
        myBend_anglerandoverride = 0;
        myBend_anglerandoptions = 0;
        myBend_anglerandinrange = UT_Vector2D(0,1);
        myBend_anglerandoutrange = UT_Vector2D(0,1);
        myBend_anglerandremapramp = UT_SharedPtr<UT_Ramp>(0);
        myBend_anglerandcurveattrib = "anglerandscale"_UTsh;
        myBend_anglerandattrib = "anglerandscale"_UTsh;
        myBend_anglerandtexture = ""_UTsh;
        myBend_anglerandtextureprim = "mask"_UTsh;
        myBend_angleranduvmode = 0;
        myBend_anglerandbias = 0.5;
        myBend_anglerandbiasoverride = 0;
        myBend_anglerandbiasoptions = 0;
        myBend_anglerandbiasinrange = UT_Vector2D(0,1);
        myBend_anglerandbiasoutrange = UT_Vector2D(0,1);
        myBend_anglerandbiasremapramp = UT_SharedPtr<UT_Ramp>(0);
        myBend_anglerandbiascurveattrib = "anglerandbiasscale"_UTsh;
        myBend_anglerandbiasattrib = "anglerandbiasscale"_UTsh;
        myBend_anglerandbiastexture = ""_UTsh;
        myBend_anglerandbiastextureprim = "mask"_UTsh;
        myBend_anglerandbiasuvmode = 0;

    }

    explicit SOP_GuideProcessCoreParms(const SOP_GuideProcessCoreParms &) = default;
    SOP_GuideProcessCoreParms &operator=(const SOP_GuideProcessCoreParms &) = default;
    SOP_GuideProcessCoreParms(SOP_GuideProcessCoreParms &&) noexcept = default;
    SOP_GuideProcessCoreParms &operator=(SOP_GuideProcessCoreParms &&) noexcept = default;

    ~SOP_GuideProcessCoreParms() override {}

    bool operator==(const SOP_GuideProcessCoreParms &src) const
    {
        if (myGeotype != src.myGeotype) return false;
        if (myBarbside != src.myBarbside) return false;
        if (myUvattrib != src.myUvattrib) return false;
        if (myGrouptype != src.myGrouptype) return false;
        if (myGroup != src.myGroup) return false;
        if (mySeed != src.mySeed) return false;
        if (myVismasks != src.myVismasks) return false;
        if (myBlend != src.myBlend) return false;
        if (myBlendoverride != src.myBlendoverride) return false;
        if (myBlendcurveattrib != src.myBlendcurveattrib) return false;
        if (myBlendattrib != src.myBlendattrib) return false;
        if (myBlendtexture != src.myBlendtexture) return false;
        if (myOp != src.myOp) return false;
        if (mySetlength_mode != src.mySetlength_mode) return false;
        if (mySetlength_method != src.mySetlength_method) return false;
        if (mySetlength_blend != src.mySetlength_blend) return false;
        if (mySetlength_randomize != src.mySetlength_randomize) return false;
        if (mySetlength_length != src.mySetlength_length) return false;
        if (mySetlength_lengthoverride != src.mySetlength_lengthoverride) return false;
        if (mySetlength_lengthoptions != src.mySetlength_lengthoptions) return false;
        if (mySetlength_lengthinrange != src.mySetlength_lengthinrange) return false;
        if (mySetlength_lengthoutrange != src.mySetlength_lengthoutrange) return false;
        if (mySetlength_lengthremapramp != src.mySetlength_lengthremapramp)
        { if (!mySetlength_lengthremapramp || !src.mySetlength_lengthremapramp || !(*mySetlength_lengthremapramp == *src.mySetlength_lengthremapramp)) return false; }
        if (mySetlength_lengthcurveattrib != src.mySetlength_lengthcurveattrib) return false;
        if (mySetlength_lengthattrib != src.mySetlength_lengthattrib) return false;
        if (mySetlength_lengthtexture != src.mySetlength_lengthtexture) return false;
        if (mySetlength_lengthtextureprim != src.mySetlength_lengthtextureprim) return false;
        if (mySetlength_lengthuvmode != src.mySetlength_lengthuvmode) return false;
        if (mySetlength_lengthrandmin != src.mySetlength_lengthrandmin) return false;
        if (mySetlength_lengthrandminoverride != src.mySetlength_lengthrandminoverride) return false;
        if (mySetlength_lengthrandminoptions != src.mySetlength_lengthrandminoptions) return false;
        if (mySetlength_lengthrandmininrange != src.mySetlength_lengthrandmininrange) return false;
        if (mySetlength_lengthrandminoutrange != src.mySetlength_lengthrandminoutrange) return false;
        if (mySetlength_lengthrandminremapramp != src.mySetlength_lengthrandminremapramp)
        { if (!mySetlength_lengthrandminremapramp || !src.mySetlength_lengthrandminremapramp || !(*mySetlength_lengthrandminremapramp == *src.mySetlength_lengthrandminremapramp)) return false; }
        if (mySetlength_lengthrandmincurveattrib != src.mySetlength_lengthrandmincurveattrib) return false;
        if (mySetlength_lengthrandminattrib != src.mySetlength_lengthrandminattrib) return false;
        if (mySetlength_lengthrandmintexture != src.mySetlength_lengthrandmintexture) return false;
        if (mySetlength_lengthrandmintextureprim != src.mySetlength_lengthrandmintextureprim) return false;
        if (mySetlength_lengthrandminuvmode != src.mySetlength_lengthrandminuvmode) return false;
        if (mySetlength_lengthrandmax != src.mySetlength_lengthrandmax) return false;
        if (mySetlength_lengthrandmaxoverride != src.mySetlength_lengthrandmaxoverride) return false;
        if (mySetlength_lengthrandmaxoptions != src.mySetlength_lengthrandmaxoptions) return false;
        if (mySetlength_lengthrandmaxinrange != src.mySetlength_lengthrandmaxinrange) return false;
        if (mySetlength_lengthrandmaxoutrange != src.mySetlength_lengthrandmaxoutrange) return false;
        if (mySetlength_lengthrandmaxremapramp != src.mySetlength_lengthrandmaxremapramp)
        { if (!mySetlength_lengthrandmaxremapramp || !src.mySetlength_lengthrandmaxremapramp || !(*mySetlength_lengthrandmaxremapramp == *src.mySetlength_lengthrandmaxremapramp)) return false; }
        if (mySetlength_lengthrandmaxcurveattrib != src.mySetlength_lengthrandmaxcurveattrib) return false;
        if (mySetlength_lengthrandmaxattrib != src.mySetlength_lengthrandmaxattrib) return false;
        if (mySetlength_lengthrandmaxtexture != src.mySetlength_lengthrandmaxtexture) return false;
        if (mySetlength_lengthrandmaxtextureprim != src.mySetlength_lengthrandmaxtextureprim) return false;
        if (mySetlength_lengthrandmaxuvmode != src.mySetlength_lengthrandmaxuvmode) return false;
        if (mySetlength_scalefactor != src.mySetlength_scalefactor) return false;
        if (mySetlength_scalefactoroverride != src.mySetlength_scalefactoroverride) return false;
        if (mySetlength_scalefactoroptions != src.mySetlength_scalefactoroptions) return false;
        if (mySetlength_scalefactorinrange != src.mySetlength_scalefactorinrange) return false;
        if (mySetlength_scalefactoroutrange != src.mySetlength_scalefactoroutrange) return false;
        if (mySetlength_scalefactorremapramp != src.mySetlength_scalefactorremapramp)
        { if (!mySetlength_scalefactorremapramp || !src.mySetlength_scalefactorremapramp || !(*mySetlength_scalefactorremapramp == *src.mySetlength_scalefactorremapramp)) return false; }
        if (mySetlength_scalefactorcurveattrib != src.mySetlength_scalefactorcurveattrib) return false;
        if (mySetlength_scalefactorattrib != src.mySetlength_scalefactorattrib) return false;
        if (mySetlength_scalefactortexture != src.mySetlength_scalefactortexture) return false;
        if (mySetlength_scalefactortextureprim != src.mySetlength_scalefactortextureprim) return false;
        if (mySetlength_scalefactoruvmode != src.mySetlength_scalefactoruvmode) return false;
        if (mySetlength_scalefactorrandmin != src.mySetlength_scalefactorrandmin) return false;
        if (mySetlength_scalefactorrandminoverride != src.mySetlength_scalefactorrandminoverride) return false;
        if (mySetlength_scalefactorrandminoptions != src.mySetlength_scalefactorrandminoptions) return false;
        if (mySetlength_scalefactorrandmininrange != src.mySetlength_scalefactorrandmininrange) return false;
        if (mySetlength_scalefactorrandminoutrange != src.mySetlength_scalefactorrandminoutrange) return false;
        if (mySetlength_scalefactorrandminremapramp != src.mySetlength_scalefactorrandminremapramp)
        { if (!mySetlength_scalefactorrandminremapramp || !src.mySetlength_scalefactorrandminremapramp || !(*mySetlength_scalefactorrandminremapramp == *src.mySetlength_scalefactorrandminremapramp)) return false; }
        if (mySetlength_scalefactorrandmincurveattrib != src.mySetlength_scalefactorrandmincurveattrib) return false;
        if (mySetlength_scalefactorrandminattrib != src.mySetlength_scalefactorrandminattrib) return false;
        if (mySetlength_scalefactorrandmintexture != src.mySetlength_scalefactorrandmintexture) return false;
        if (mySetlength_scalefactorrandmintextureprim != src.mySetlength_scalefactorrandmintextureprim) return false;
        if (mySetlength_scalefactorrandminuvmode != src.mySetlength_scalefactorrandminuvmode) return false;
        if (mySetlength_scalefactorrandmax != src.mySetlength_scalefactorrandmax) return false;
        if (mySetlength_scalefactorrandmaxoverride != src.mySetlength_scalefactorrandmaxoverride) return false;
        if (mySetlength_scalefactorrandmaxoptions != src.mySetlength_scalefactorrandmaxoptions) return false;
        if (mySetlength_scalefactorrandmaxinrange != src.mySetlength_scalefactorrandmaxinrange) return false;
        if (mySetlength_scalefactorrandmaxoutrange != src.mySetlength_scalefactorrandmaxoutrange) return false;
        if (mySetlength_scalefactorrandmaxremapramp != src.mySetlength_scalefactorrandmaxremapramp)
        { if (!mySetlength_scalefactorrandmaxremapramp || !src.mySetlength_scalefactorrandmaxremapramp || !(*mySetlength_scalefactorrandmaxremapramp == *src.mySetlength_scalefactorrandmaxremapramp)) return false; }
        if (mySetlength_scalefactorrandmaxcurveattrib != src.mySetlength_scalefactorrandmaxcurveattrib) return false;
        if (mySetlength_scalefactorrandmaxattrib != src.mySetlength_scalefactorrandmaxattrib) return false;
        if (mySetlength_scalefactorrandmaxtexture != src.mySetlength_scalefactorrandmaxtexture) return false;
        if (mySetlength_scalefactorrandmaxtextureprim != src.mySetlength_scalefactorrandmaxtextureprim) return false;
        if (mySetlength_scalefactorrandmaxuvmode != src.mySetlength_scalefactorrandmaxuvmode) return false;
        if (mySetlength_cullzerolen != src.mySetlength_cullzerolen) return false;
        if (mySetlength_cullthreshold != src.mySetlength_cullthreshold) return false;
        if (myBend_blend != src.myBend_blend) return false;
        if (myBend_axismode != src.myBend_axismode) return false;
        if (myBend_axis != src.myBend_axis) return false;
        if (myBend_axiscurveattrib != src.myBend_axiscurveattrib) return false;
        if (myBend_axisskinattrib != src.myBend_axisskinattrib) return false;
        if (myBend_dir != src.myBend_dir) return false;
        if (myBend_dircurveattrib != src.myBend_dircurveattrib) return false;
        if (myBend_dirskinattrib != src.myBend_dirskinattrib) return false;
        if (myBend_dirtoaxis != src.myBend_dirtoaxis) return false;
        if (myBend_angle != src.myBend_angle) return false;
        if (myBend_angleoverride != src.myBend_angleoverride) return false;
        if (myBend_angleoptions != src.myBend_angleoptions) return false;
        if (myBend_angleinrange != src.myBend_angleinrange) return false;
        if (myBend_angleoutrange != src.myBend_angleoutrange) return false;
        if (myBend_anglemapramptobarbs != src.myBend_anglemapramptobarbs) return false;
        if (myBend_angleremapramp != src.myBend_angleremapramp)
        { if (!myBend_angleremapramp || !src.myBend_angleremapramp || !(*myBend_angleremapramp == *src.myBend_angleremapramp)) return false; }
        if (myBend_anglecurveattrib != src.myBend_anglecurveattrib) return false;
        if (myBend_angleattrib != src.myBend_angleattrib) return false;
        if (myBend_angletexture != src.myBend_angletexture) return false;
        if (myBend_angletextureprim != src.myBend_angletextureprim) return false;
        if (myBend_angleuvmode != src.myBend_angleuvmode) return false;
        if (myBend_anglerand != src.myBend_anglerand) return false;
        if (myBend_anglerandoverride != src.myBend_anglerandoverride) return false;
        if (myBend_anglerandoptions != src.myBend_anglerandoptions) return false;
        if (myBend_anglerandinrange != src.myBend_anglerandinrange) return false;
        if (myBend_anglerandoutrange != src.myBend_anglerandoutrange) return false;
        if (myBend_anglerandremapramp != src.myBend_anglerandremapramp)
        { if (!myBend_anglerandremapramp || !src.myBend_anglerandremapramp || !(*myBend_anglerandremapramp == *src.myBend_anglerandremapramp)) return false; }
        if (myBend_anglerandcurveattrib != src.myBend_anglerandcurveattrib) return false;
        if (myBend_anglerandattrib != src.myBend_anglerandattrib) return false;
        if (myBend_anglerandtexture != src.myBend_anglerandtexture) return false;
        if (myBend_anglerandtextureprim != src.myBend_anglerandtextureprim) return false;
        if (myBend_angleranduvmode != src.myBend_angleranduvmode) return false;
        if (myBend_anglerandbias != src.myBend_anglerandbias) return false;
        if (myBend_anglerandbiasoverride != src.myBend_anglerandbiasoverride) return false;
        if (myBend_anglerandbiasoptions != src.myBend_anglerandbiasoptions) return false;
        if (myBend_anglerandbiasinrange != src.myBend_anglerandbiasinrange) return false;
        if (myBend_anglerandbiasoutrange != src.myBend_anglerandbiasoutrange) return false;
        if (myBend_anglerandbiasremapramp != src.myBend_anglerandbiasremapramp)
        { if (!myBend_anglerandbiasremapramp || !src.myBend_anglerandbiasremapramp || !(*myBend_anglerandbiasremapramp == *src.myBend_anglerandbiasremapramp)) return false; }
        if (myBend_anglerandbiascurveattrib != src.myBend_anglerandbiascurveattrib) return false;
        if (myBend_anglerandbiasattrib != src.myBend_anglerandbiasattrib) return false;
        if (myBend_anglerandbiastexture != src.myBend_anglerandbiastexture) return false;
        if (myBend_anglerandbiastextureprim != src.myBend_anglerandbiastextureprim) return false;
        if (myBend_anglerandbiasuvmode != src.myBend_anglerandbiasuvmode) return false;

        return true;
    }
    bool operator!=(const SOP_GuideProcessCoreParms &src) const
    {
        return !operator==(src);
    }
    using Geotype = SOP_GuideProcessCoreEnums::Geotype;
    using Grouptype = SOP_GuideProcessCoreEnums::Grouptype;
    using Blendoverride = SOP_GuideProcessCoreEnums::Blendoverride;
    using Op = SOP_GuideProcessCoreEnums::Op;
    using Setlength_mode = SOP_GuideProcessCoreEnums::Setlength_mode;
    using Setlength_method = SOP_GuideProcessCoreEnums::Setlength_method;
    using Setlength_lengthoverride = SOP_GuideProcessCoreEnums::Setlength_lengthoverride;
    using Setlength_lengthuvmode = SOP_GuideProcessCoreEnums::Setlength_lengthuvmode;
    using Setlength_lengthrandminoverride = SOP_GuideProcessCoreEnums::Setlength_lengthrandminoverride;
    using Setlength_lengthrandminuvmode = SOP_GuideProcessCoreEnums::Setlength_lengthrandminuvmode;
    using Setlength_lengthrandmaxoverride = SOP_GuideProcessCoreEnums::Setlength_lengthrandmaxoverride;
    using Setlength_lengthrandmaxuvmode = SOP_GuideProcessCoreEnums::Setlength_lengthrandmaxuvmode;
    using Setlength_scalefactoroverride = SOP_GuideProcessCoreEnums::Setlength_scalefactoroverride;
    using Setlength_scalefactoruvmode = SOP_GuideProcessCoreEnums::Setlength_scalefactoruvmode;
    using Setlength_scalefactorrandminoverride = SOP_GuideProcessCoreEnums::Setlength_scalefactorrandminoverride;
    using Setlength_scalefactorrandminuvmode = SOP_GuideProcessCoreEnums::Setlength_scalefactorrandminuvmode;
    using Setlength_scalefactorrandmaxoverride = SOP_GuideProcessCoreEnums::Setlength_scalefactorrandmaxoverride;
    using Setlength_scalefactorrandmaxuvmode = SOP_GuideProcessCoreEnums::Setlength_scalefactorrandmaxuvmode;
    using Bend_axismode = SOP_GuideProcessCoreEnums::Bend_axismode;
    using Bend_dirtoaxis = SOP_GuideProcessCoreEnums::Bend_dirtoaxis;
    using Bend_angleoverride = SOP_GuideProcessCoreEnums::Bend_angleoverride;
    using Bend_angleuvmode = SOP_GuideProcessCoreEnums::Bend_angleuvmode;
    using Bend_anglerandoverride = SOP_GuideProcessCoreEnums::Bend_anglerandoverride;
    using Bend_angleranduvmode = SOP_GuideProcessCoreEnums::Bend_angleranduvmode;
    using Bend_anglerandbiasoverride = SOP_GuideProcessCoreEnums::Bend_anglerandbiasoverride;
    using Bend_anglerandbiasuvmode = SOP_GuideProcessCoreEnums::Bend_anglerandbiasuvmode;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGeotype = 0;
        if (true)
            graph->evalOpParm(myGeotype, nodeidx, "geotype", time, 0);
        myBarbside = 3;
        if (true)
            graph->evalOpParm(myBarbside, nodeidx, "barbside", time, 0);
        myUvattrib = "uv"_UTsh;
        if (true)
            graph->evalOpParm(myUvattrib, nodeidx, "uvattrib", time, 0);
        myGrouptype = 0;
        if (true)
            graph->evalOpParm(myGrouptype, nodeidx, "grouptype", time, 0);
        myGroup = ""_UTsh;
        if (true)
            graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
        mySeed = 0;
        if (true)
            graph->evalOpParm(mySeed, nodeidx, "seed", time, 0);
        myVismasks = true;
        if (true)
            graph->evalOpParm(myVismasks, nodeidx, "vismasks", time, 0);
        myBlend = 1;
        if (true)
            graph->evalOpParm(myBlend, nodeidx, "blend", time, 0);
        myBlendoverride = 0;
        if (true)
            graph->evalOpParm(myBlendoverride, nodeidx, "blendoverride", time, 0);
        myBlendcurveattrib = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getBlendoverride())!=1)))) ) )
            graph->evalOpParm(myBlendcurveattrib, nodeidx, "blendcurveattrib", time, 0);
        myBlendattrib = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getBlendoverride())!=2)))) ) )
            graph->evalOpParm(myBlendattrib, nodeidx, "blendattrib", time, 0);
        myBlendtexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getBlendoverride())!=3)))) ) )
            graph->evalOpParm(myBlendtexture, nodeidx, "blendtexture", time, 0);
        myOp = 0;
        if (true)
            graph->evalOpParm(myOp, nodeidx, "op", time, 0);
        mySetlength_mode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_mode, nodeidx, "setlength_mode", time, 0);
        mySetlength_method = 1;
        if (true && ( (true&&!(((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_method, nodeidx, "setlength_method", time, 0);
        mySetlength_blend = 1;
        if (true && ( (true&&!(((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_blend, nodeidx, "setlength_blend", time, 0);
        mySetlength_randomize = false;
        if (true && ( (true&&!(((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_randomize, nodeidx, "setlength_randomize", time, 0);
        mySetlength_length = 0.1;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0)))) ) )
            graph->evalOpParm(mySetlength_length, nodeidx, "setlength_length", time, 0);
        mySetlength_lengthoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0)))) ) )
            graph->evalOpParm(mySetlength_lengthoverride, nodeidx, "setlength_lengthoverride", time, 0);
        mySetlength_lengthoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0)))) ) )
            graph->evalOpParm(mySetlength_lengthoptions, nodeidx, "setlength_lengthoptions", time, 0);
        mySetlength_lengthinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((getSetlength_lengthoptions()!=1)&&(getSetlength_lengthoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthinrange, nodeidx, "setlength_lengthinrange", time, 0);
        mySetlength_lengthoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((getSetlength_lengthoptions()!=1)&&(getSetlength_lengthoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthoutrange, nodeidx, "setlength_lengthoutrange", time, 0);
        mySetlength_lengthremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((getSetlength_lengthoptions()!=2)&&(getSetlength_lengthoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthremapramp, nodeidx, "setlength_lengthremapramp", time, 0);
        mySetlength_lengthcurveattrib = "length"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((int64(getSetlength_lengthoverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_lengthcurveattrib, nodeidx, "setlength_lengthcurveattrib", time, 0);
        mySetlength_lengthattrib = "length"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((int64(getSetlength_lengthoverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_lengthattrib, nodeidx, "setlength_lengthattrib", time, 0);
        mySetlength_lengthtexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((int64(getSetlength_lengthoverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthtexture, nodeidx, "setlength_lengthtexture", time, 0);
        mySetlength_lengthtextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((int64(getSetlength_lengthoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthtextureprim, nodeidx, "setlength_lengthtextureprim", time, 0);
        mySetlength_lengthuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()!=0))||((int64(getSetlength_lengthoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthuvmode, nodeidx, "setlength_lengthuvmode", time, 0);
        mySetlength_lengthrandmin = 0.1;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmin, nodeidx, "setlength_lengthrandmin", time, 0);
        mySetlength_lengthrandminoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminoverride, nodeidx, "setlength_lengthrandminoverride", time, 0);
        mySetlength_lengthrandminoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminoptions, nodeidx, "setlength_lengthrandminoptions", time, 0);
        mySetlength_lengthrandmininrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthrandminoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandminoptions()!=1)&&(getSetlength_lengthrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmininrange, nodeidx, "setlength_lengthrandmininrange", time, 0);
        mySetlength_lengthrandminoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthrandminoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandminoptions()!=1)&&(getSetlength_lengthrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminoutrange, nodeidx, "setlength_lengthrandminoutrange", time, 0);
        mySetlength_lengthrandminremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandminoptions()!=2)&&(getSetlength_lengthrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminremapramp, nodeidx, "setlength_lengthrandminremapramp", time, 0);
        mySetlength_lengthrandmincurveattrib = "minlength"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandminoverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmincurveattrib, nodeidx, "setlength_lengthrandmincurveattrib", time, 0);
        mySetlength_lengthrandminattrib = "minlength"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandminoverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminattrib, nodeidx, "setlength_lengthrandminattrib", time, 0);
        mySetlength_lengthrandmintexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandminoverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmintexture, nodeidx, "setlength_lengthrandmintexture", time, 0);
        mySetlength_lengthrandmintextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandminoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmintextureprim, nodeidx, "setlength_lengthrandmintextureprim", time, 0);
        mySetlength_lengthrandminuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandminoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthrandminuvmode, nodeidx, "setlength_lengthrandminuvmode", time, 0);
        mySetlength_lengthrandmax = 0.2;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmax, nodeidx, "setlength_lengthrandmax", time, 0);
        mySetlength_lengthrandmaxoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxoverride, nodeidx, "setlength_lengthrandmaxoverride", time, 0);
        mySetlength_lengthrandmaxoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxoptions, nodeidx, "setlength_lengthrandmaxoptions", time, 0);
        mySetlength_lengthrandmaxinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthrandmaxoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandmaxoptions()!=1)&&(getSetlength_lengthrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxinrange, nodeidx, "setlength_lengthrandmaxinrange", time, 0);
        mySetlength_lengthrandmaxoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_lengthrandmaxoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandmaxoptions()!=1)&&(getSetlength_lengthrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxoutrange, nodeidx, "setlength_lengthrandmaxoutrange", time, 0);
        mySetlength_lengthrandmaxremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((getSetlength_lengthrandmaxoptions()!=2)&&(getSetlength_lengthrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxremapramp, nodeidx, "setlength_lengthrandmaxremapramp", time, 0);
        mySetlength_lengthrandmaxcurveattrib = "maxlength"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandmaxoverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxcurveattrib, nodeidx, "setlength_lengthrandmaxcurveattrib", time, 0);
        mySetlength_lengthrandmaxattrib = "maxlength"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandmaxoverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxattrib, nodeidx, "setlength_lengthrandmaxattrib", time, 0);
        mySetlength_lengthrandmaxtexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandmaxoverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxtexture, nodeidx, "setlength_lengthrandmaxtexture", time, 0);
        mySetlength_lengthrandmaxtextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandmaxoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxtextureprim, nodeidx, "setlength_lengthrandmaxtextureprim", time, 0);
        mySetlength_lengthrandmaxuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())==1))||((getSetlength_randomize()==0))||((int64(getSetlength_lengthrandmaxoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_lengthrandmaxuvmode, nodeidx, "setlength_lengthrandmaxuvmode", time, 0);
        mySetlength_scalefactor = 1;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1)))) ) )
            graph->evalOpParm(mySetlength_scalefactor, nodeidx, "setlength_scalefactor", time, 0);
        mySetlength_scalefactoroverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1)))) ) )
            graph->evalOpParm(mySetlength_scalefactoroverride, nodeidx, "setlength_scalefactoroverride", time, 0);
        mySetlength_scalefactoroptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1)))) ) )
            graph->evalOpParm(mySetlength_scalefactoroptions, nodeidx, "setlength_scalefactoroptions", time, 0);
        mySetlength_scalefactorinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactoroverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((getSetlength_scalefactoroptions()!=1)&&(getSetlength_scalefactoroptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorinrange, nodeidx, "setlength_scalefactorinrange", time, 0);
        mySetlength_scalefactoroutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactoroverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((getSetlength_scalefactoroptions()!=1)&&(getSetlength_scalefactoroptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactoroutrange, nodeidx, "setlength_scalefactoroutrange", time, 0);
        mySetlength_scalefactorremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((getSetlength_scalefactoroptions()!=2)&&(getSetlength_scalefactoroptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorremapramp, nodeidx, "setlength_scalefactorremapramp", time, 0);
        mySetlength_scalefactorcurveattrib = "scalefactor"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((int64(getSetlength_scalefactoroverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_scalefactorcurveattrib, nodeidx, "setlength_scalefactorcurveattrib", time, 0);
        mySetlength_scalefactorattrib = "scalefactor"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((int64(getSetlength_scalefactoroverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_scalefactorattrib, nodeidx, "setlength_scalefactorattrib", time, 0);
        mySetlength_scalefactortexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((int64(getSetlength_scalefactoroverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactortexture, nodeidx, "setlength_scalefactortexture", time, 0);
        mySetlength_scalefactortextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((int64(getSetlength_scalefactoroverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactortextureprim, nodeidx, "setlength_scalefactortextureprim", time, 0);
        mySetlength_scalefactoruvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==1))||((int64(getSetlength_scalefactoroverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactoruvmode, nodeidx, "setlength_scalefactoruvmode", time, 0);
        mySetlength_scalefactorrandmin = 1;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmin, nodeidx, "setlength_scalefactorrandmin", time, 0);
        mySetlength_scalefactorrandminoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminoverride, nodeidx, "setlength_scalefactorrandminoverride", time, 0);
        mySetlength_scalefactorrandminoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminoptions, nodeidx, "setlength_scalefactorrandminoptions", time, 0);
        mySetlength_scalefactorrandmininrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactorrandminoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandminoptions()!=1)&&(getSetlength_scalefactorrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmininrange, nodeidx, "setlength_scalefactorrandmininrange", time, 0);
        mySetlength_scalefactorrandminoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactorrandminoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandminoptions()!=1)&&(getSetlength_scalefactorrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminoutrange, nodeidx, "setlength_scalefactorrandminoutrange", time, 0);
        mySetlength_scalefactorrandminremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandminoptions()!=2)&&(getSetlength_scalefactorrandminoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminremapramp, nodeidx, "setlength_scalefactorrandminremapramp", time, 0);
        mySetlength_scalefactorrandmincurveattrib = "scalefactormin"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandminoverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmincurveattrib, nodeidx, "setlength_scalefactorrandmincurveattrib", time, 0);
        mySetlength_scalefactorrandminattrib = "scalefactormin"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandminoverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminattrib, nodeidx, "setlength_scalefactorrandminattrib", time, 0);
        mySetlength_scalefactorrandmintexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandminoverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmintexture, nodeidx, "setlength_scalefactorrandmintexture", time, 0);
        mySetlength_scalefactorrandmintextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandminoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmintextureprim, nodeidx, "setlength_scalefactorrandmintextureprim", time, 0);
        mySetlength_scalefactorrandminuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandminoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandminuvmode, nodeidx, "setlength_scalefactorrandminuvmode", time, 0);
        mySetlength_scalefactorrandmax = 1;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmax, nodeidx, "setlength_scalefactorrandmax", time, 0);
        mySetlength_scalefactorrandmaxoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxoverride, nodeidx, "setlength_scalefactorrandmaxoverride", time, 0);
        mySetlength_scalefactorrandmaxoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxoptions, nodeidx, "setlength_scalefactorrandmaxoptions", time, 0);
        mySetlength_scalefactorrandmaxinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactorrandmaxoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandmaxoptions()!=1)&&(getSetlength_scalefactorrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxinrange, nodeidx, "setlength_scalefactorrandmaxinrange", time, 0);
        mySetlength_scalefactorrandmaxoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getSetlength_scalefactorrandmaxoverride())==0))||((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandmaxoptions()!=1)&&(getSetlength_scalefactorrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxoutrange, nodeidx, "setlength_scalefactorrandmaxoutrange", time, 0);
        mySetlength_scalefactorrandmaxremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((getSetlength_scalefactorrandmaxoptions()!=2)&&(getSetlength_scalefactorrandmaxoptions()!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxremapramp, nodeidx, "setlength_scalefactorrandmaxremapramp", time, 0);
        mySetlength_scalefactorrandmaxcurveattrib = "scalefactormax"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandmaxoverride())!=1)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxcurveattrib, nodeidx, "setlength_scalefactorrandmaxcurveattrib", time, 0);
        mySetlength_scalefactorrandmaxattrib = "scalefactormax"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandmaxoverride())!=2)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxattrib, nodeidx, "setlength_scalefactorrandmaxattrib", time, 0);
        mySetlength_scalefactorrandmaxtexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandmaxoverride())!=3)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxtexture, nodeidx, "setlength_scalefactorrandmaxtexture", time, 0);
        mySetlength_scalefactorrandmaxtextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandmaxoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxtextureprim, nodeidx, "setlength_scalefactorrandmaxtextureprim", time, 0);
        mySetlength_scalefactorrandmaxuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=0))||((int64(getSetlength_mode())!=1))||((getSetlength_randomize()==0))||((int64(getSetlength_scalefactorrandmaxoverride())!=4)))) ) )
            graph->evalOpParm(mySetlength_scalefactorrandmaxuvmode, nodeidx, "setlength_scalefactorrandmaxuvmode", time, 0);
        mySetlength_cullzerolen = true;
        if (true && ( (true&&!(((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_cullzerolen, nodeidx, "setlength_cullzerolen", time, 0);
        mySetlength_cullthreshold = 0.0001;
        if (true && ( (true&&!(((getSetlength_cullzerolen()==0))||((int64(getOp())!=0)))) ) )
            graph->evalOpParm(mySetlength_cullthreshold, nodeidx, "setlength_cullthreshold", time, 0);
        myBend_blend = 1;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_blend, nodeidx, "bend_blend", time, 0);
        myBend_axismode = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_axismode, nodeidx, "bend_axismode", time, 0);
        myBend_axis = UT_Vector3D(0,0,-1);
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=4)))) ) )
            graph->evalOpParm(myBend_axis, nodeidx, "bend_axis", time, 0);
        myBend_axiscurveattrib = "bendaxis"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=5)))) ) )
            graph->evalOpParm(myBend_axiscurveattrib, nodeidx, "bend_axiscurveattrib", time, 0);
        myBend_axisskinattrib = "bendaxis"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=6)))) ) )
            graph->evalOpParm(myBend_axisskinattrib, nodeidx, "bend_axisskinattrib", time, 0);
        myBend_dir = UT_Vector3D(0,0,-1);
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=1)))) ) )
            graph->evalOpParm(myBend_dir, nodeidx, "bend_dir", time, 0);
        myBend_dircurveattrib = "benddir"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=2)))) ) )
            graph->evalOpParm(myBend_dircurveattrib, nodeidx, "bend_dircurveattrib", time, 0);
        myBend_dirskinattrib = "benddir"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=3)))) ) )
            graph->evalOpParm(myBend_dirskinattrib, nodeidx, "bend_dirskinattrib", time, 0);
        myBend_dirtoaxis = 0;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_axismode())!=0)&&(int64(getBend_axismode())!=1)&&(int64(getBend_axismode())!=2)&&(int64(getBend_axismode())!=3)))) ) )
            graph->evalOpParm(myBend_dirtoaxis, nodeidx, "bend_dirtoaxis", time, 0);
        myBend_angle = 15;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_angle, nodeidx, "bend_angle", time, 0);
        myBend_angleoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_angleoverride, nodeidx, "bend_angleoverride", time, 0);
        myBend_angleoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_angleoptions, nodeidx, "bend_angleoptions", time, 0);
        myBend_angleinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_angleoverride())==0))||((int64(getOp())!=1))||((getBend_angleoptions()!=1)&&(getBend_angleoptions()!=3)))) ) )
            graph->evalOpParm(myBend_angleinrange, nodeidx, "bend_angleinrange", time, 0);
        myBend_angleoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_angleoverride())==0))||((int64(getOp())!=1))||((getBend_angleoptions()!=1)&&(getBend_angleoptions()!=3)))) ) )
            graph->evalOpParm(myBend_angleoutrange, nodeidx, "bend_angleoutrange", time, 0);
        myBend_anglemapramptobarbs = false;
        if (true && ( (true&&!(((int64(getOp())!=1))||((getBend_angleoptions()!=2)&&(getBend_angleoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglemapramptobarbs, nodeidx, "bend_anglemapramptobarbs", time, 0);
        myBend_angleremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=1))||((getBend_angleoptions()!=2)&&(getBend_angleoptions()!=3)))) ) )
            graph->evalOpParm(myBend_angleremapramp, nodeidx, "bend_angleremapramp", time, 0);
        myBend_anglecurveattrib = "anglescale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_angleoverride())!=1)))) ) )
            graph->evalOpParm(myBend_anglecurveattrib, nodeidx, "bend_anglecurveattrib", time, 0);
        myBend_angleattrib = "anglescale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_angleoverride())!=2)))) ) )
            graph->evalOpParm(myBend_angleattrib, nodeidx, "bend_angleattrib", time, 0);
        myBend_angletexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_angleoverride())!=3)))) ) )
            graph->evalOpParm(myBend_angletexture, nodeidx, "bend_angletexture", time, 0);
        myBend_angletextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_angleoverride())!=4)))) ) )
            graph->evalOpParm(myBend_angletextureprim, nodeidx, "bend_angletextureprim", time, 0);
        myBend_angleuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_angleoverride())!=4)))) ) )
            graph->evalOpParm(myBend_angleuvmode, nodeidx, "bend_angleuvmode", time, 0);
        myBend_anglerand = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerand, nodeidx, "bend_anglerand", time, 0);
        myBend_anglerandoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandoverride, nodeidx, "bend_anglerandoverride", time, 0);
        myBend_anglerandoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandoptions, nodeidx, "bend_anglerandoptions", time, 0);
        myBend_anglerandinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_anglerandoverride())==0))||((int64(getOp())!=1))||((getBend_anglerandoptions()!=1)&&(getBend_anglerandoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandinrange, nodeidx, "bend_anglerandinrange", time, 0);
        myBend_anglerandoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_anglerandoverride())==0))||((int64(getOp())!=1))||((getBend_anglerandoptions()!=1)&&(getBend_anglerandoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandoutrange, nodeidx, "bend_anglerandoutrange", time, 0);
        myBend_anglerandremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=1))||((getBend_anglerandoptions()!=2)&&(getBend_anglerandoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandremapramp, nodeidx, "bend_anglerandremapramp", time, 0);
        myBend_anglerandcurveattrib = "anglerandscale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandoverride())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandcurveattrib, nodeidx, "bend_anglerandcurveattrib", time, 0);
        myBend_anglerandattrib = "anglerandscale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandoverride())!=2)))) ) )
            graph->evalOpParm(myBend_anglerandattrib, nodeidx, "bend_anglerandattrib", time, 0);
        myBend_anglerandtexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandoverride())!=3)))) ) )
            graph->evalOpParm(myBend_anglerandtexture, nodeidx, "bend_anglerandtexture", time, 0);
        myBend_anglerandtextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandoverride())!=4)))) ) )
            graph->evalOpParm(myBend_anglerandtextureprim, nodeidx, "bend_anglerandtextureprim", time, 0);
        myBend_angleranduvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandoverride())!=4)))) ) )
            graph->evalOpParm(myBend_angleranduvmode, nodeidx, "bend_angleranduvmode", time, 0);
        myBend_anglerandbias = 0.5;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandbias, nodeidx, "bend_anglerandbias", time, 0);
        myBend_anglerandbiasoverride = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandbiasoverride, nodeidx, "bend_anglerandbiasoverride", time, 0);
        myBend_anglerandbiasoptions = 0;
        if (true && ( (true&&!(((int64(getOp())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandbiasoptions, nodeidx, "bend_anglerandbiasoptions", time, 0);
        myBend_anglerandbiasinrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_anglerandbiasoverride())==0))||((int64(getOp())!=1))||((getBend_anglerandbiasoptions()!=1)&&(getBend_anglerandbiasoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandbiasinrange, nodeidx, "bend_anglerandbiasinrange", time, 0);
        myBend_anglerandbiasoutrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((int64(getBend_anglerandbiasoverride())==0))||((int64(getOp())!=1))||((getBend_anglerandbiasoptions()!=1)&&(getBend_anglerandbiasoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandbiasoutrange, nodeidx, "bend_anglerandbiasoutrange", time, 0);
        myBend_anglerandbiasremapramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getOp())!=1))||((getBend_anglerandbiasoptions()!=2)&&(getBend_anglerandbiasoptions()!=3)))) ) )
            graph->evalOpParm(myBend_anglerandbiasremapramp, nodeidx, "bend_anglerandbiasremapramp", time, 0);
        myBend_anglerandbiascurveattrib = "anglerandbiasscale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandbiasoverride())!=1)))) ) )
            graph->evalOpParm(myBend_anglerandbiascurveattrib, nodeidx, "bend_anglerandbiascurveattrib", time, 0);
        myBend_anglerandbiasattrib = "anglerandbiasscale"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandbiasoverride())!=2)))) ) )
            graph->evalOpParm(myBend_anglerandbiasattrib, nodeidx, "bend_anglerandbiasattrib", time, 0);
        myBend_anglerandbiastexture = ""_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandbiasoverride())!=3)))) ) )
            graph->evalOpParm(myBend_anglerandbiastexture, nodeidx, "bend_anglerandbiastexture", time, 0);
        myBend_anglerandbiastextureprim = "mask"_UTsh;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandbiasoverride())!=4)))) ) )
            graph->evalOpParm(myBend_anglerandbiastextureprim, nodeidx, "bend_anglerandbiastextureprim", time, 0);
        myBend_anglerandbiasuvmode = 0;
        if (true && ( (true&&!(((int64(getOp())!=1))||((int64(getBend_anglerandbiasoverride())!=4)))) ) )
            graph->evalOpParm(myBend_anglerandbiasuvmode, nodeidx, "bend_anglerandbiasuvmode", time, 0);

    }


    void loadFromOpSubclass(const LoadParms &loadparms) override
    {
        buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
    }


    void copyFrom(const OP_NodeParms *src) override
    {
        *this = *((const SOP_GuideProcessCoreParms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myGeotype);
                break;
            case 1:
                coerceValue(value, myBarbside);
                break;
            case 2:
                coerceValue(value, myUvattrib);
                break;
            case 3:
                coerceValue(value, myGrouptype);
                break;
            case 4:
                coerceValue(value, myGroup);
                break;
            case 5:
                coerceValue(value, mySeed);
                break;
            case 6:
                coerceValue(value, myVismasks);
                break;
            case 7:
                coerceValue(value, myBlend);
                break;
            case 8:
                coerceValue(value, myBlendoverride);
                break;
            case 9:
                coerceValue(value, myBlendcurveattrib);
                break;
            case 10:
                coerceValue(value, myBlendattrib);
                break;
            case 11:
                coerceValue(value, myBlendtexture);
                break;
            case 12:
                coerceValue(value, myOp);
                break;
            case 13:
                coerceValue(value, mySetlength_mode);
                break;
            case 14:
                coerceValue(value, mySetlength_method);
                break;
            case 15:
                coerceValue(value, mySetlength_blend);
                break;
            case 16:
                coerceValue(value, mySetlength_randomize);
                break;
            case 17:
                coerceValue(value, mySetlength_length);
                break;
            case 18:
                coerceValue(value, mySetlength_lengthoverride);
                break;
            case 19:
                coerceValue(value, mySetlength_lengthoptions);
                break;
            case 20:
                coerceValue(value, mySetlength_lengthinrange);
                break;
            case 21:
                coerceValue(value, mySetlength_lengthoutrange);
                break;
            case 22:
                coerceValue(value, mySetlength_lengthremapramp);
                break;
            case 23:
                coerceValue(value, mySetlength_lengthcurveattrib);
                break;
            case 24:
                coerceValue(value, mySetlength_lengthattrib);
                break;
            case 25:
                coerceValue(value, mySetlength_lengthtexture);
                break;
            case 26:
                coerceValue(value, mySetlength_lengthtextureprim);
                break;
            case 27:
                coerceValue(value, mySetlength_lengthuvmode);
                break;
            case 28:
                coerceValue(value, mySetlength_lengthrandmin);
                break;
            case 29:
                coerceValue(value, mySetlength_lengthrandminoverride);
                break;
            case 30:
                coerceValue(value, mySetlength_lengthrandminoptions);
                break;
            case 31:
                coerceValue(value, mySetlength_lengthrandmininrange);
                break;
            case 32:
                coerceValue(value, mySetlength_lengthrandminoutrange);
                break;
            case 33:
                coerceValue(value, mySetlength_lengthrandminremapramp);
                break;
            case 34:
                coerceValue(value, mySetlength_lengthrandmincurveattrib);
                break;
            case 35:
                coerceValue(value, mySetlength_lengthrandminattrib);
                break;
            case 36:
                coerceValue(value, mySetlength_lengthrandmintexture);
                break;
            case 37:
                coerceValue(value, mySetlength_lengthrandmintextureprim);
                break;
            case 38:
                coerceValue(value, mySetlength_lengthrandminuvmode);
                break;
            case 39:
                coerceValue(value, mySetlength_lengthrandmax);
                break;
            case 40:
                coerceValue(value, mySetlength_lengthrandmaxoverride);
                break;
            case 41:
                coerceValue(value, mySetlength_lengthrandmaxoptions);
                break;
            case 42:
                coerceValue(value, mySetlength_lengthrandmaxinrange);
                break;
            case 43:
                coerceValue(value, mySetlength_lengthrandmaxoutrange);
                break;
            case 44:
                coerceValue(value, mySetlength_lengthrandmaxremapramp);
                break;
            case 45:
                coerceValue(value, mySetlength_lengthrandmaxcurveattrib);
                break;
            case 46:
                coerceValue(value, mySetlength_lengthrandmaxattrib);
                break;
            case 47:
                coerceValue(value, mySetlength_lengthrandmaxtexture);
                break;
            case 48:
                coerceValue(value, mySetlength_lengthrandmaxtextureprim);
                break;
            case 49:
                coerceValue(value, mySetlength_lengthrandmaxuvmode);
                break;
            case 50:
                coerceValue(value, mySetlength_scalefactor);
                break;
            case 51:
                coerceValue(value, mySetlength_scalefactoroverride);
                break;
            case 52:
                coerceValue(value, mySetlength_scalefactoroptions);
                break;
            case 53:
                coerceValue(value, mySetlength_scalefactorinrange);
                break;
            case 54:
                coerceValue(value, mySetlength_scalefactoroutrange);
                break;
            case 55:
                coerceValue(value, mySetlength_scalefactorremapramp);
                break;
            case 56:
                coerceValue(value, mySetlength_scalefactorcurveattrib);
                break;
            case 57:
                coerceValue(value, mySetlength_scalefactorattrib);
                break;
            case 58:
                coerceValue(value, mySetlength_scalefactortexture);
                break;
            case 59:
                coerceValue(value, mySetlength_scalefactortextureprim);
                break;
            case 60:
                coerceValue(value, mySetlength_scalefactoruvmode);
                break;
            case 61:
                coerceValue(value, mySetlength_scalefactorrandmin);
                break;
            case 62:
                coerceValue(value, mySetlength_scalefactorrandminoverride);
                break;
            case 63:
                coerceValue(value, mySetlength_scalefactorrandminoptions);
                break;
            case 64:
                coerceValue(value, mySetlength_scalefactorrandmininrange);
                break;
            case 65:
                coerceValue(value, mySetlength_scalefactorrandminoutrange);
                break;
            case 66:
                coerceValue(value, mySetlength_scalefactorrandminremapramp);
                break;
            case 67:
                coerceValue(value, mySetlength_scalefactorrandmincurveattrib);
                break;
            case 68:
                coerceValue(value, mySetlength_scalefactorrandminattrib);
                break;
            case 69:
                coerceValue(value, mySetlength_scalefactorrandmintexture);
                break;
            case 70:
                coerceValue(value, mySetlength_scalefactorrandmintextureprim);
                break;
            case 71:
                coerceValue(value, mySetlength_scalefactorrandminuvmode);
                break;
            case 72:
                coerceValue(value, mySetlength_scalefactorrandmax);
                break;
            case 73:
                coerceValue(value, mySetlength_scalefactorrandmaxoverride);
                break;
            case 74:
                coerceValue(value, mySetlength_scalefactorrandmaxoptions);
                break;
            case 75:
                coerceValue(value, mySetlength_scalefactorrandmaxinrange);
                break;
            case 76:
                coerceValue(value, mySetlength_scalefactorrandmaxoutrange);
                break;
            case 77:
                coerceValue(value, mySetlength_scalefactorrandmaxremapramp);
                break;
            case 78:
                coerceValue(value, mySetlength_scalefactorrandmaxcurveattrib);
                break;
            case 79:
                coerceValue(value, mySetlength_scalefactorrandmaxattrib);
                break;
            case 80:
                coerceValue(value, mySetlength_scalefactorrandmaxtexture);
                break;
            case 81:
                coerceValue(value, mySetlength_scalefactorrandmaxtextureprim);
                break;
            case 82:
                coerceValue(value, mySetlength_scalefactorrandmaxuvmode);
                break;
            case 83:
                coerceValue(value, mySetlength_cullzerolen);
                break;
            case 84:
                coerceValue(value, mySetlength_cullthreshold);
                break;
            case 85:
                coerceValue(value, myBend_blend);
                break;
            case 86:
                coerceValue(value, myBend_axismode);
                break;
            case 87:
                coerceValue(value, myBend_axis);
                break;
            case 88:
                coerceValue(value, myBend_axiscurveattrib);
                break;
            case 89:
                coerceValue(value, myBend_axisskinattrib);
                break;
            case 90:
                coerceValue(value, myBend_dir);
                break;
            case 91:
                coerceValue(value, myBend_dircurveattrib);
                break;
            case 92:
                coerceValue(value, myBend_dirskinattrib);
                break;
            case 93:
                coerceValue(value, myBend_dirtoaxis);
                break;
            case 94:
                coerceValue(value, myBend_angle);
                break;
            case 95:
                coerceValue(value, myBend_angleoverride);
                break;
            case 96:
                coerceValue(value, myBend_angleoptions);
                break;
            case 97:
                coerceValue(value, myBend_angleinrange);
                break;
            case 98:
                coerceValue(value, myBend_angleoutrange);
                break;
            case 99:
                coerceValue(value, myBend_anglemapramptobarbs);
                break;
            case 100:
                coerceValue(value, myBend_angleremapramp);
                break;
            case 101:
                coerceValue(value, myBend_anglecurveattrib);
                break;
            case 102:
                coerceValue(value, myBend_angleattrib);
                break;
            case 103:
                coerceValue(value, myBend_angletexture);
                break;
            case 104:
                coerceValue(value, myBend_angletextureprim);
                break;
            case 105:
                coerceValue(value, myBend_angleuvmode);
                break;
            case 106:
                coerceValue(value, myBend_anglerand);
                break;
            case 107:
                coerceValue(value, myBend_anglerandoverride);
                break;
            case 108:
                coerceValue(value, myBend_anglerandoptions);
                break;
            case 109:
                coerceValue(value, myBend_anglerandinrange);
                break;
            case 110:
                coerceValue(value, myBend_anglerandoutrange);
                break;
            case 111:
                coerceValue(value, myBend_anglerandremapramp);
                break;
            case 112:
                coerceValue(value, myBend_anglerandcurveattrib);
                break;
            case 113:
                coerceValue(value, myBend_anglerandattrib);
                break;
            case 114:
                coerceValue(value, myBend_anglerandtexture);
                break;
            case 115:
                coerceValue(value, myBend_anglerandtextureprim);
                break;
            case 116:
                coerceValue(value, myBend_angleranduvmode);
                break;
            case 117:
                coerceValue(value, myBend_anglerandbias);
                break;
            case 118:
                coerceValue(value, myBend_anglerandbiasoverride);
                break;
            case 119:
                coerceValue(value, myBend_anglerandbiasoptions);
                break;
            case 120:
                coerceValue(value, myBend_anglerandbiasinrange);
                break;
            case 121:
                coerceValue(value, myBend_anglerandbiasoutrange);
                break;
            case 122:
                coerceValue(value, myBend_anglerandbiasremapramp);
                break;
            case 123:
                coerceValue(value, myBend_anglerandbiascurveattrib);
                break;
            case 124:
                coerceValue(value, myBend_anglerandbiasattrib);
                break;
            case 125:
                coerceValue(value, myBend_anglerandbiastexture);
                break;
            case 126:
                coerceValue(value, myBend_anglerandbiastextureprim);
                break;
            case 127:
                coerceValue(value, myBend_anglerandbiasuvmode);
                break;

        }
    }

    bool isParmColorRamp(exint idx) const override
    { 
            switch (idx)
            {

            }
            return false;
    }

    void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
    { doGetParmValue(idx, instance, value); }

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myGeotype, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 1:
                coerceValue(myBarbside, ( ( value ) ));
                break;
            case 2:
                coerceValue(myUvattrib, ( ( value ) ));
                break;
            case 3:
                coerceValue(myGrouptype, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 4:
                coerceValue(myGroup, ( ( value ) ));
                break;
            case 5:
                coerceValue(mySeed, ( ( value ) ));
                break;
            case 6:
                coerceValue(myVismasks, ( ( value ) ));
                break;
            case 7:
                coerceValue(myBlend, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 8:
                coerceValue(myBlendoverride, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 9:
                coerceValue(myBlendcurveattrib, ( ( value ) ));
                break;
            case 10:
                coerceValue(myBlendattrib, ( ( value ) ));
                break;
            case 11:
                coerceValue(myBlendtexture, ( ( value ) ));
                break;
            case 12:
                coerceValue(myOp, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 13:
                coerceValue(mySetlength_mode, clampMinValue(0,  clampMaxValue(5,  value ) ));
                break;
            case 14:
                coerceValue(mySetlength_method, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 15:
                coerceValue(mySetlength_blend, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 16:
                coerceValue(mySetlength_randomize, ( ( value ) ));
                break;
            case 17:
                coerceValue(mySetlength_length, clampMinValue(0,  ( value ) ));
                break;
            case 18:
                coerceValue(mySetlength_lengthoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 19:
                coerceValue(mySetlength_lengthoptions, ( ( value ) ));
                break;
            case 20:
                coerceValue(mySetlength_lengthinrange, ( ( value ) ));
                break;
            case 21:
                coerceValue(mySetlength_lengthoutrange, ( ( value ) ));
                break;
            case 22:
                coerceValue(mySetlength_lengthremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 23:
                coerceValue(mySetlength_lengthcurveattrib, ( ( value ) ));
                break;
            case 24:
                coerceValue(mySetlength_lengthattrib, ( ( value ) ));
                break;
            case 25:
                coerceValue(mySetlength_lengthtexture, ( ( value ) ));
                break;
            case 26:
                coerceValue(mySetlength_lengthtextureprim, ( ( value ) ));
                break;
            case 27:
                coerceValue(mySetlength_lengthuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 28:
                coerceValue(mySetlength_lengthrandmin, clampMinValue(0,  ( value ) ));
                break;
            case 29:
                coerceValue(mySetlength_lengthrandminoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 30:
                coerceValue(mySetlength_lengthrandminoptions, ( ( value ) ));
                break;
            case 31:
                coerceValue(mySetlength_lengthrandmininrange, ( ( value ) ));
                break;
            case 32:
                coerceValue(mySetlength_lengthrandminoutrange, ( ( value ) ));
                break;
            case 33:
                coerceValue(mySetlength_lengthrandminremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 34:
                coerceValue(mySetlength_lengthrandmincurveattrib, ( ( value ) ));
                break;
            case 35:
                coerceValue(mySetlength_lengthrandminattrib, ( ( value ) ));
                break;
            case 36:
                coerceValue(mySetlength_lengthrandmintexture, ( ( value ) ));
                break;
            case 37:
                coerceValue(mySetlength_lengthrandmintextureprim, ( ( value ) ));
                break;
            case 38:
                coerceValue(mySetlength_lengthrandminuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 39:
                coerceValue(mySetlength_lengthrandmax, clampMinValue(0,  ( value ) ));
                break;
            case 40:
                coerceValue(mySetlength_lengthrandmaxoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 41:
                coerceValue(mySetlength_lengthrandmaxoptions, ( ( value ) ));
                break;
            case 42:
                coerceValue(mySetlength_lengthrandmaxinrange, ( ( value ) ));
                break;
            case 43:
                coerceValue(mySetlength_lengthrandmaxoutrange, ( ( value ) ));
                break;
            case 44:
                coerceValue(mySetlength_lengthrandmaxremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 45:
                coerceValue(mySetlength_lengthrandmaxcurveattrib, ( ( value ) ));
                break;
            case 46:
                coerceValue(mySetlength_lengthrandmaxattrib, ( ( value ) ));
                break;
            case 47:
                coerceValue(mySetlength_lengthrandmaxtexture, ( ( value ) ));
                break;
            case 48:
                coerceValue(mySetlength_lengthrandmaxtextureprim, ( ( value ) ));
                break;
            case 49:
                coerceValue(mySetlength_lengthrandmaxuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 50:
                coerceValue(mySetlength_scalefactor, ( ( value ) ));
                break;
            case 51:
                coerceValue(mySetlength_scalefactoroverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 52:
                coerceValue(mySetlength_scalefactoroptions, ( ( value ) ));
                break;
            case 53:
                coerceValue(mySetlength_scalefactorinrange, ( ( value ) ));
                break;
            case 54:
                coerceValue(mySetlength_scalefactoroutrange, ( ( value ) ));
                break;
            case 55:
                coerceValue(mySetlength_scalefactorremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 56:
                coerceValue(mySetlength_scalefactorcurveattrib, ( ( value ) ));
                break;
            case 57:
                coerceValue(mySetlength_scalefactorattrib, ( ( value ) ));
                break;
            case 58:
                coerceValue(mySetlength_scalefactortexture, ( ( value ) ));
                break;
            case 59:
                coerceValue(mySetlength_scalefactortextureprim, ( ( value ) ));
                break;
            case 60:
                coerceValue(mySetlength_scalefactoruvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 61:
                coerceValue(mySetlength_scalefactorrandmin, ( ( value ) ));
                break;
            case 62:
                coerceValue(mySetlength_scalefactorrandminoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 63:
                coerceValue(mySetlength_scalefactorrandminoptions, ( ( value ) ));
                break;
            case 64:
                coerceValue(mySetlength_scalefactorrandmininrange, ( ( value ) ));
                break;
            case 65:
                coerceValue(mySetlength_scalefactorrandminoutrange, ( ( value ) ));
                break;
            case 66:
                coerceValue(mySetlength_scalefactorrandminremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 67:
                coerceValue(mySetlength_scalefactorrandmincurveattrib, ( ( value ) ));
                break;
            case 68:
                coerceValue(mySetlength_scalefactorrandminattrib, ( ( value ) ));
                break;
            case 69:
                coerceValue(mySetlength_scalefactorrandmintexture, ( ( value ) ));
                break;
            case 70:
                coerceValue(mySetlength_scalefactorrandmintextureprim, ( ( value ) ));
                break;
            case 71:
                coerceValue(mySetlength_scalefactorrandminuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 72:
                coerceValue(mySetlength_scalefactorrandmax, ( ( value ) ));
                break;
            case 73:
                coerceValue(mySetlength_scalefactorrandmaxoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 74:
                coerceValue(mySetlength_scalefactorrandmaxoptions, ( ( value ) ));
                break;
            case 75:
                coerceValue(mySetlength_scalefactorrandmaxinrange, ( ( value ) ));
                break;
            case 76:
                coerceValue(mySetlength_scalefactorrandmaxoutrange, ( ( value ) ));
                break;
            case 77:
                coerceValue(mySetlength_scalefactorrandmaxremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 78:
                coerceValue(mySetlength_scalefactorrandmaxcurveattrib, ( ( value ) ));
                break;
            case 79:
                coerceValue(mySetlength_scalefactorrandmaxattrib, ( ( value ) ));
                break;
            case 80:
                coerceValue(mySetlength_scalefactorrandmaxtexture, ( ( value ) ));
                break;
            case 81:
                coerceValue(mySetlength_scalefactorrandmaxtextureprim, ( ( value ) ));
                break;
            case 82:
                coerceValue(mySetlength_scalefactorrandmaxuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 83:
                coerceValue(mySetlength_cullzerolen, ( ( value ) ));
                break;
            case 84:
                coerceValue(mySetlength_cullthreshold, ( clampMaxValue(-10,  value ) ));
                break;
            case 85:
                coerceValue(myBend_blend, ( ( value ) ));
                break;
            case 86:
                coerceValue(myBend_axismode, clampMinValue(0,  clampMaxValue(6,  value ) ));
                break;
            case 87:
                coerceValue(myBend_axis, ( ( value ) ));
                break;
            case 88:
                coerceValue(myBend_axiscurveattrib, ( ( value ) ));
                break;
            case 89:
                coerceValue(myBend_axisskinattrib, ( ( value ) ));
                break;
            case 90:
                coerceValue(myBend_dir, ( ( value ) ));
                break;
            case 91:
                coerceValue(myBend_dircurveattrib, ( ( value ) ));
                break;
            case 92:
                coerceValue(myBend_dirskinattrib, ( ( value ) ));
                break;
            case 93:
                coerceValue(myBend_dirtoaxis, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 94:
                coerceValue(myBend_angle, ( ( value ) ));
                break;
            case 95:
                coerceValue(myBend_angleoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 96:
                coerceValue(myBend_angleoptions, ( ( value ) ));
                break;
            case 97:
                coerceValue(myBend_angleinrange, ( ( value ) ));
                break;
            case 98:
                coerceValue(myBend_angleoutrange, ( ( value ) ));
                break;
            case 99:
                coerceValue(myBend_anglemapramptobarbs, ( ( value ) ));
                break;
            case 100:
                coerceValue(myBend_angleremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 101:
                coerceValue(myBend_anglecurveattrib, ( ( value ) ));
                break;
            case 102:
                coerceValue(myBend_angleattrib, ( ( value ) ));
                break;
            case 103:
                coerceValue(myBend_angletexture, ( ( value ) ));
                break;
            case 104:
                coerceValue(myBend_angletextureprim, ( ( value ) ));
                break;
            case 105:
                coerceValue(myBend_angleuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 106:
                coerceValue(myBend_anglerand, ( ( value ) ));
                break;
            case 107:
                coerceValue(myBend_anglerandoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 108:
                coerceValue(myBend_anglerandoptions, ( ( value ) ));
                break;
            case 109:
                coerceValue(myBend_anglerandinrange, ( ( value ) ));
                break;
            case 110:
                coerceValue(myBend_anglerandoutrange, ( ( value ) ));
                break;
            case 111:
                coerceValue(myBend_anglerandremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 112:
                coerceValue(myBend_anglerandcurveattrib, ( ( value ) ));
                break;
            case 113:
                coerceValue(myBend_anglerandattrib, ( ( value ) ));
                break;
            case 114:
                coerceValue(myBend_anglerandtexture, ( ( value ) ));
                break;
            case 115:
                coerceValue(myBend_anglerandtextureprim, ( ( value ) ));
                break;
            case 116:
                coerceValue(myBend_angleranduvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 117:
                coerceValue(myBend_anglerandbias, ( ( value ) ));
                break;
            case 118:
                coerceValue(myBend_anglerandbiasoverride, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 119:
                coerceValue(myBend_anglerandbiasoptions, ( ( value ) ));
                break;
            case 120:
                coerceValue(myBend_anglerandbiasinrange, ( ( value ) ));
                break;
            case 121:
                coerceValue(myBend_anglerandbiasoutrange, ( ( value ) ));
                break;
            case 122:
                coerceValue(myBend_anglerandbiasremapramp, clampMinValue(1,  ( value ) ));
                break;
            case 123:
                coerceValue(myBend_anglerandbiascurveattrib, ( ( value ) ));
                break;
            case 124:
                coerceValue(myBend_anglerandbiasattrib, ( ( value ) ));
                break;
            case 125:
                coerceValue(myBend_anglerandbiastexture, ( ( value ) ));
                break;
            case 126:
                coerceValue(myBend_anglerandbiastextureprim, ( ( value ) ));
                break;
            case 127:
                coerceValue(myBend_anglerandbiasuvmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;

        }
    }

    void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value)  override
    { doSetParmValue(idx, instance, value); }

    exint getNestNumParms(TempIndex idx) const override
    {
        if (idx.size() == 0)
            return 128;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "geotype";
            case 1:
                return "barbside";
            case 2:
                return "uvattrib";
            case 3:
                return "grouptype";
            case 4:
                return "group";
            case 5:
                return "seed";
            case 6:
                return "vismasks";
            case 7:
                return "blend";
            case 8:
                return "blendoverride";
            case 9:
                return "blendcurveattrib";
            case 10:
                return "blendattrib";
            case 11:
                return "blendtexture";
            case 12:
                return "op";
            case 13:
                return "setlength_mode";
            case 14:
                return "setlength_method";
            case 15:
                return "setlength_blend";
            case 16:
                return "setlength_randomize";
            case 17:
                return "setlength_length";
            case 18:
                return "setlength_lengthoverride";
            case 19:
                return "setlength_lengthoptions";
            case 20:
                return "setlength_lengthinrange";
            case 21:
                return "setlength_lengthoutrange";
            case 22:
                return "setlength_lengthremapramp";
            case 23:
                return "setlength_lengthcurveattrib";
            case 24:
                return "setlength_lengthattrib";
            case 25:
                return "setlength_lengthtexture";
            case 26:
                return "setlength_lengthtextureprim";
            case 27:
                return "setlength_lengthuvmode";
            case 28:
                return "setlength_lengthrandmin";
            case 29:
                return "setlength_lengthrandminoverride";
            case 30:
                return "setlength_lengthrandminoptions";
            case 31:
                return "setlength_lengthrandmininrange";
            case 32:
                return "setlength_lengthrandminoutrange";
            case 33:
                return "setlength_lengthrandminremapramp";
            case 34:
                return "setlength_lengthrandmincurveattrib";
            case 35:
                return "setlength_lengthrandminattrib";
            case 36:
                return "setlength_lengthrandmintexture";
            case 37:
                return "setlength_lengthrandmintextureprim";
            case 38:
                return "setlength_lengthrandminuvmode";
            case 39:
                return "setlength_lengthrandmax";
            case 40:
                return "setlength_lengthrandmaxoverride";
            case 41:
                return "setlength_lengthrandmaxoptions";
            case 42:
                return "setlength_lengthrandmaxinrange";
            case 43:
                return "setlength_lengthrandmaxoutrange";
            case 44:
                return "setlength_lengthrandmaxremapramp";
            case 45:
                return "setlength_lengthrandmaxcurveattrib";
            case 46:
                return "setlength_lengthrandmaxattrib";
            case 47:
                return "setlength_lengthrandmaxtexture";
            case 48:
                return "setlength_lengthrandmaxtextureprim";
            case 49:
                return "setlength_lengthrandmaxuvmode";
            case 50:
                return "setlength_scalefactor";
            case 51:
                return "setlength_scalefactoroverride";
            case 52:
                return "setlength_scalefactoroptions";
            case 53:
                return "setlength_scalefactorinrange";
            case 54:
                return "setlength_scalefactoroutrange";
            case 55:
                return "setlength_scalefactorremapramp";
            case 56:
                return "setlength_scalefactorcurveattrib";
            case 57:
                return "setlength_scalefactorattrib";
            case 58:
                return "setlength_scalefactortexture";
            case 59:
                return "setlength_scalefactortextureprim";
            case 60:
                return "setlength_scalefactoruvmode";
            case 61:
                return "setlength_scalefactorrandmin";
            case 62:
                return "setlength_scalefactorrandminoverride";
            case 63:
                return "setlength_scalefactorrandminoptions";
            case 64:
                return "setlength_scalefactorrandmininrange";
            case 65:
                return "setlength_scalefactorrandminoutrange";
            case 66:
                return "setlength_scalefactorrandminremapramp";
            case 67:
                return "setlength_scalefactorrandmincurveattrib";
            case 68:
                return "setlength_scalefactorrandminattrib";
            case 69:
                return "setlength_scalefactorrandmintexture";
            case 70:
                return "setlength_scalefactorrandmintextureprim";
            case 71:
                return "setlength_scalefactorrandminuvmode";
            case 72:
                return "setlength_scalefactorrandmax";
            case 73:
                return "setlength_scalefactorrandmaxoverride";
            case 74:
                return "setlength_scalefactorrandmaxoptions";
            case 75:
                return "setlength_scalefactorrandmaxinrange";
            case 76:
                return "setlength_scalefactorrandmaxoutrange";
            case 77:
                return "setlength_scalefactorrandmaxremapramp";
            case 78:
                return "setlength_scalefactorrandmaxcurveattrib";
            case 79:
                return "setlength_scalefactorrandmaxattrib";
            case 80:
                return "setlength_scalefactorrandmaxtexture";
            case 81:
                return "setlength_scalefactorrandmaxtextureprim";
            case 82:
                return "setlength_scalefactorrandmaxuvmode";
            case 83:
                return "setlength_cullzerolen";
            case 84:
                return "setlength_cullthreshold";
            case 85:
                return "bend_blend";
            case 86:
                return "bend_axismode";
            case 87:
                return "bend_axis";
            case 88:
                return "bend_axiscurveattrib";
            case 89:
                return "bend_axisskinattrib";
            case 90:
                return "bend_dir";
            case 91:
                return "bend_dircurveattrib";
            case 92:
                return "bend_dirskinattrib";
            case 93:
                return "bend_dirtoaxis";
            case 94:
                return "bend_angle";
            case 95:
                return "bend_angleoverride";
            case 96:
                return "bend_angleoptions";
            case 97:
                return "bend_angleinrange";
            case 98:
                return "bend_angleoutrange";
            case 99:
                return "bend_anglemapramptobarbs";
            case 100:
                return "bend_angleremapramp";
            case 101:
                return "bend_anglecurveattrib";
            case 102:
                return "bend_angleattrib";
            case 103:
                return "bend_angletexture";
            case 104:
                return "bend_angletextureprim";
            case 105:
                return "bend_angleuvmode";
            case 106:
                return "bend_anglerand";
            case 107:
                return "bend_anglerandoverride";
            case 108:
                return "bend_anglerandoptions";
            case 109:
                return "bend_anglerandinrange";
            case 110:
                return "bend_anglerandoutrange";
            case 111:
                return "bend_anglerandremapramp";
            case 112:
                return "bend_anglerandcurveattrib";
            case 113:
                return "bend_anglerandattrib";
            case 114:
                return "bend_anglerandtexture";
            case 115:
                return "bend_anglerandtextureprim";
            case 116:
                return "bend_angleranduvmode";
            case 117:
                return "bend_anglerandbias";
            case 118:
                return "bend_anglerandbiasoverride";
            case 119:
                return "bend_anglerandbiasoptions";
            case 120:
                return "bend_anglerandbiasinrange";
            case 121:
                return "bend_anglerandbiasoutrange";
            case 122:
                return "bend_anglerandbiasremapramp";
            case 123:
                return "bend_anglerandbiascurveattrib";
            case 124:
                return "bend_anglerandbiasattrib";
            case 125:
                return "bend_anglerandbiastexture";
            case 126:
                return "bend_anglerandbiastextureprim";
            case 127:
                return "bend_anglerandbiasuvmode";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_INTEGER;
            case 1:
                return PARM_INTEGER;
            case 2:
                return PARM_STRING;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_STRING;
            case 5:
                return PARM_FLOAT;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_FLOAT;
            case 8:
                return PARM_INTEGER;
            case 9:
                return PARM_STRING;
            case 10:
                return PARM_STRING;
            case 11:
                return PARM_STRING;
            case 12:
                return PARM_INTEGER;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_FLOAT;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_FLOAT;
            case 18:
                return PARM_INTEGER;
            case 19:
                return PARM_INTEGER;
            case 20:
                return PARM_VECTOR2;
            case 21:
                return PARM_VECTOR2;
            case 22:
                return PARM_RAMP;
            case 23:
                return PARM_STRING;
            case 24:
                return PARM_STRING;
            case 25:
                return PARM_STRING;
            case 26:
                return PARM_STRING;
            case 27:
                return PARM_INTEGER;
            case 28:
                return PARM_FLOAT;
            case 29:
                return PARM_INTEGER;
            case 30:
                return PARM_INTEGER;
            case 31:
                return PARM_VECTOR2;
            case 32:
                return PARM_VECTOR2;
            case 33:
                return PARM_RAMP;
            case 34:
                return PARM_STRING;
            case 35:
                return PARM_STRING;
            case 36:
                return PARM_STRING;
            case 37:
                return PARM_STRING;
            case 38:
                return PARM_INTEGER;
            case 39:
                return PARM_FLOAT;
            case 40:
                return PARM_INTEGER;
            case 41:
                return PARM_INTEGER;
            case 42:
                return PARM_VECTOR2;
            case 43:
                return PARM_VECTOR2;
            case 44:
                return PARM_RAMP;
            case 45:
                return PARM_STRING;
            case 46:
                return PARM_STRING;
            case 47:
                return PARM_STRING;
            case 48:
                return PARM_STRING;
            case 49:
                return PARM_INTEGER;
            case 50:
                return PARM_FLOAT;
            case 51:
                return PARM_INTEGER;
            case 52:
                return PARM_INTEGER;
            case 53:
                return PARM_VECTOR2;
            case 54:
                return PARM_VECTOR2;
            case 55:
                return PARM_RAMP;
            case 56:
                return PARM_STRING;
            case 57:
                return PARM_STRING;
            case 58:
                return PARM_STRING;
            case 59:
                return PARM_STRING;
            case 60:
                return PARM_INTEGER;
            case 61:
                return PARM_FLOAT;
            case 62:
                return PARM_INTEGER;
            case 63:
                return PARM_INTEGER;
            case 64:
                return PARM_VECTOR2;
            case 65:
                return PARM_VECTOR2;
            case 66:
                return PARM_RAMP;
            case 67:
                return PARM_STRING;
            case 68:
                return PARM_STRING;
            case 69:
                return PARM_STRING;
            case 70:
                return PARM_STRING;
            case 71:
                return PARM_INTEGER;
            case 72:
                return PARM_FLOAT;
            case 73:
                return PARM_INTEGER;
            case 74:
                return PARM_INTEGER;
            case 75:
                return PARM_VECTOR2;
            case 76:
                return PARM_VECTOR2;
            case 77:
                return PARM_RAMP;
            case 78:
                return PARM_STRING;
            case 79:
                return PARM_STRING;
            case 80:
                return PARM_STRING;
            case 81:
                return PARM_STRING;
            case 82:
                return PARM_INTEGER;
            case 83:
                return PARM_INTEGER;
            case 84:
                return PARM_FLOAT;
            case 85:
                return PARM_FLOAT;
            case 86:
                return PARM_INTEGER;
            case 87:
                return PARM_VECTOR3;
            case 88:
                return PARM_STRING;
            case 89:
                return PARM_STRING;
            case 90:
                return PARM_VECTOR3;
            case 91:
                return PARM_STRING;
            case 92:
                return PARM_STRING;
            case 93:
                return PARM_INTEGER;
            case 94:
                return PARM_FLOAT;
            case 95:
                return PARM_INTEGER;
            case 96:
                return PARM_INTEGER;
            case 97:
                return PARM_VECTOR2;
            case 98:
                return PARM_VECTOR2;
            case 99:
                return PARM_INTEGER;
            case 100:
                return PARM_RAMP;
            case 101:
                return PARM_STRING;
            case 102:
                return PARM_STRING;
            case 103:
                return PARM_STRING;
            case 104:
                return PARM_STRING;
            case 105:
                return PARM_INTEGER;
            case 106:
                return PARM_FLOAT;
            case 107:
                return PARM_INTEGER;
            case 108:
                return PARM_INTEGER;
            case 109:
                return PARM_VECTOR2;
            case 110:
                return PARM_VECTOR2;
            case 111:
                return PARM_RAMP;
            case 112:
                return PARM_STRING;
            case 113:
                return PARM_STRING;
            case 114:
                return PARM_STRING;
            case 115:
                return PARM_STRING;
            case 116:
                return PARM_INTEGER;
            case 117:
                return PARM_FLOAT;
            case 118:
                return PARM_INTEGER;
            case 119:
                return PARM_INTEGER;
            case 120:
                return PARM_VECTOR2;
            case 121:
                return PARM_VECTOR2;
            case 122:
                return PARM_RAMP;
            case 123:
                return PARM_STRING;
            case 124:
                return PARM_STRING;
            case 125:
                return PARM_STRING;
            case 126:
                return PARM_STRING;
            case 127:
                return PARM_INTEGER;

        }
        return PARM_UNSUPPORTED;
    }

    // Boiler plate to load individual types.
    static void  loadData(UT_IStream &is, int64 &v)
    { is.bread(&v, 1); }
    static void  loadData(UT_IStream &is, bool &v)
    { int64     iv; is.bread(&iv, 1); v = iv; }
    static void  loadData(UT_IStream &is, fpreal64 &v)
    { is.bread<fpreal64>(&v, 1); }
    static void  loadData(UT_IStream &is, UT_Vector2D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix2D &v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix3D &v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix4D &v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Vector2I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_StringHolder &v)
    { is.bread(v); }
    static void  loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
    {   UT_StringHolder   rampdata;
        loadData(is, rampdata);
        if (rampdata.isstring())
        {
            v.reset(new UT_Ramp());
            UT_IStream  istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
            v->load(istr);
        }
        else v.reset();
    }
    static void  loadData(UT_IStream &is, PRM_DataItemHandle &v)
    {   UT_StringHolder   data;
        loadData(is, data);
        if (data.isstring())
        {
            // Find the data type.
            const char *colon = UT_StringWrap(data).findChar(':');
            if (colon)
            {
                int             typelen = colon - data.buffer();
                UT_WorkBuffer   type;
                type.strncpy(data.buffer(), typelen);
                UT_IStream  istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
                
                v = PRM_DataFactory::parseBinary(type.buffer(), istr);
            }
        }
        else v.reset();
    }

    static void  saveData(std::ostream &os, int64 v)
    { UTwrite(os, &v); }
    static void  saveData(std::ostream &os, bool v)
    { int64 iv = v; UTwrite(os, &iv); }
    static void  saveData(std::ostream &os, fpreal64 v)
    { UTwrite<fpreal64>(os, &v); }
    static void  saveData(std::ostream &os, UT_Vector2D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
    static void  saveData(std::ostream &os, UT_Vector3D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); }
    static void  saveData(std::ostream &os, UT_Vector4D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
    static void  saveData(std::ostream &os, UT_Matrix2D v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix3D v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix4D v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_StringHolder s)
    { UT_StringWrap(s).saveBinary(os); }
    static void  saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) s->save(ostr);
        result = ostr.str();
        saveData(os, result);
    }
    static void  saveData(std::ostream &os, PRM_DataItemHandle s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) 
        {
            ostr << s->getDataTypeToken();
            ostr << ":";
            s->saveBinary(ostr);
        }
        result = ostr.str();
        saveData(os, result);
    }


    void         save(std::ostream &os) const
    {
        int32           v = version();
        UTwrite(os, &v);
        saveData(os, myGeotype);
        saveData(os, myBarbside);
        saveData(os, myUvattrib);
        saveData(os, myGrouptype);
        saveData(os, myGroup);
        saveData(os, mySeed);
        saveData(os, myVismasks);
        saveData(os, myBlend);
        saveData(os, myBlendoverride);
        saveData(os, myBlendcurveattrib);
        saveData(os, myBlendattrib);
        saveData(os, myBlendtexture);
        saveData(os, myOp);
        saveData(os, mySetlength_mode);
        saveData(os, mySetlength_method);
        saveData(os, mySetlength_blend);
        saveData(os, mySetlength_randomize);
        saveData(os, mySetlength_length);
        saveData(os, mySetlength_lengthoverride);
        saveData(os, mySetlength_lengthoptions);
        saveData(os, mySetlength_lengthinrange);
        saveData(os, mySetlength_lengthoutrange);
        saveData(os, mySetlength_lengthremapramp);
        saveData(os, mySetlength_lengthcurveattrib);
        saveData(os, mySetlength_lengthattrib);
        saveData(os, mySetlength_lengthtexture);
        saveData(os, mySetlength_lengthtextureprim);
        saveData(os, mySetlength_lengthuvmode);
        saveData(os, mySetlength_lengthrandmin);
        saveData(os, mySetlength_lengthrandminoverride);
        saveData(os, mySetlength_lengthrandminoptions);
        saveData(os, mySetlength_lengthrandmininrange);
        saveData(os, mySetlength_lengthrandminoutrange);
        saveData(os, mySetlength_lengthrandminremapramp);
        saveData(os, mySetlength_lengthrandmincurveattrib);
        saveData(os, mySetlength_lengthrandminattrib);
        saveData(os, mySetlength_lengthrandmintexture);
        saveData(os, mySetlength_lengthrandmintextureprim);
        saveData(os, mySetlength_lengthrandminuvmode);
        saveData(os, mySetlength_lengthrandmax);
        saveData(os, mySetlength_lengthrandmaxoverride);
        saveData(os, mySetlength_lengthrandmaxoptions);
        saveData(os, mySetlength_lengthrandmaxinrange);
        saveData(os, mySetlength_lengthrandmaxoutrange);
        saveData(os, mySetlength_lengthrandmaxremapramp);
        saveData(os, mySetlength_lengthrandmaxcurveattrib);
        saveData(os, mySetlength_lengthrandmaxattrib);
        saveData(os, mySetlength_lengthrandmaxtexture);
        saveData(os, mySetlength_lengthrandmaxtextureprim);
        saveData(os, mySetlength_lengthrandmaxuvmode);
        saveData(os, mySetlength_scalefactor);
        saveData(os, mySetlength_scalefactoroverride);
        saveData(os, mySetlength_scalefactoroptions);
        saveData(os, mySetlength_scalefactorinrange);
        saveData(os, mySetlength_scalefactoroutrange);
        saveData(os, mySetlength_scalefactorremapramp);
        saveData(os, mySetlength_scalefactorcurveattrib);
        saveData(os, mySetlength_scalefactorattrib);
        saveData(os, mySetlength_scalefactortexture);
        saveData(os, mySetlength_scalefactortextureprim);
        saveData(os, mySetlength_scalefactoruvmode);
        saveData(os, mySetlength_scalefactorrandmin);
        saveData(os, mySetlength_scalefactorrandminoverride);
        saveData(os, mySetlength_scalefactorrandminoptions);
        saveData(os, mySetlength_scalefactorrandmininrange);
        saveData(os, mySetlength_scalefactorrandminoutrange);
        saveData(os, mySetlength_scalefactorrandminremapramp);
        saveData(os, mySetlength_scalefactorrandmincurveattrib);
        saveData(os, mySetlength_scalefactorrandminattrib);
        saveData(os, mySetlength_scalefactorrandmintexture);
        saveData(os, mySetlength_scalefactorrandmintextureprim);
        saveData(os, mySetlength_scalefactorrandminuvmode);
        saveData(os, mySetlength_scalefactorrandmax);
        saveData(os, mySetlength_scalefactorrandmaxoverride);
        saveData(os, mySetlength_scalefactorrandmaxoptions);
        saveData(os, mySetlength_scalefactorrandmaxinrange);
        saveData(os, mySetlength_scalefactorrandmaxoutrange);
        saveData(os, mySetlength_scalefactorrandmaxremapramp);
        saveData(os, mySetlength_scalefactorrandmaxcurveattrib);
        saveData(os, mySetlength_scalefactorrandmaxattrib);
        saveData(os, mySetlength_scalefactorrandmaxtexture);
        saveData(os, mySetlength_scalefactorrandmaxtextureprim);
        saveData(os, mySetlength_scalefactorrandmaxuvmode);
        saveData(os, mySetlength_cullzerolen);
        saveData(os, mySetlength_cullthreshold);
        saveData(os, myBend_blend);
        saveData(os, myBend_axismode);
        saveData(os, myBend_axis);
        saveData(os, myBend_axiscurveattrib);
        saveData(os, myBend_axisskinattrib);
        saveData(os, myBend_dir);
        saveData(os, myBend_dircurveattrib);
        saveData(os, myBend_dirskinattrib);
        saveData(os, myBend_dirtoaxis);
        saveData(os, myBend_angle);
        saveData(os, myBend_angleoverride);
        saveData(os, myBend_angleoptions);
        saveData(os, myBend_angleinrange);
        saveData(os, myBend_angleoutrange);
        saveData(os, myBend_anglemapramptobarbs);
        saveData(os, myBend_angleremapramp);
        saveData(os, myBend_anglecurveattrib);
        saveData(os, myBend_angleattrib);
        saveData(os, myBend_angletexture);
        saveData(os, myBend_angletextureprim);
        saveData(os, myBend_angleuvmode);
        saveData(os, myBend_anglerand);
        saveData(os, myBend_anglerandoverride);
        saveData(os, myBend_anglerandoptions);
        saveData(os, myBend_anglerandinrange);
        saveData(os, myBend_anglerandoutrange);
        saveData(os, myBend_anglerandremapramp);
        saveData(os, myBend_anglerandcurveattrib);
        saveData(os, myBend_anglerandattrib);
        saveData(os, myBend_anglerandtexture);
        saveData(os, myBend_anglerandtextureprim);
        saveData(os, myBend_angleranduvmode);
        saveData(os, myBend_anglerandbias);
        saveData(os, myBend_anglerandbiasoverride);
        saveData(os, myBend_anglerandbiasoptions);
        saveData(os, myBend_anglerandbiasinrange);
        saveData(os, myBend_anglerandbiasoutrange);
        saveData(os, myBend_anglerandbiasremapramp);
        saveData(os, myBend_anglerandbiascurveattrib);
        saveData(os, myBend_anglerandbiasattrib);
        saveData(os, myBend_anglerandbiastexture);
        saveData(os, myBend_anglerandbiastextureprim);
        saveData(os, myBend_anglerandbiasuvmode);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGeotype);
        loadData(is, myBarbside);
        loadData(is, myUvattrib);
        loadData(is, myGrouptype);
        loadData(is, myGroup);
        loadData(is, mySeed);
        loadData(is, myVismasks);
        loadData(is, myBlend);
        loadData(is, myBlendoverride);
        loadData(is, myBlendcurveattrib);
        loadData(is, myBlendattrib);
        loadData(is, myBlendtexture);
        loadData(is, myOp);
        loadData(is, mySetlength_mode);
        loadData(is, mySetlength_method);
        loadData(is, mySetlength_blend);
        loadData(is, mySetlength_randomize);
        loadData(is, mySetlength_length);
        loadData(is, mySetlength_lengthoverride);
        loadData(is, mySetlength_lengthoptions);
        loadData(is, mySetlength_lengthinrange);
        loadData(is, mySetlength_lengthoutrange);
        loadData(is, mySetlength_lengthremapramp);
        loadData(is, mySetlength_lengthcurveattrib);
        loadData(is, mySetlength_lengthattrib);
        loadData(is, mySetlength_lengthtexture);
        loadData(is, mySetlength_lengthtextureprim);
        loadData(is, mySetlength_lengthuvmode);
        loadData(is, mySetlength_lengthrandmin);
        loadData(is, mySetlength_lengthrandminoverride);
        loadData(is, mySetlength_lengthrandminoptions);
        loadData(is, mySetlength_lengthrandmininrange);
        loadData(is, mySetlength_lengthrandminoutrange);
        loadData(is, mySetlength_lengthrandminremapramp);
        loadData(is, mySetlength_lengthrandmincurveattrib);
        loadData(is, mySetlength_lengthrandminattrib);
        loadData(is, mySetlength_lengthrandmintexture);
        loadData(is, mySetlength_lengthrandmintextureprim);
        loadData(is, mySetlength_lengthrandminuvmode);
        loadData(is, mySetlength_lengthrandmax);
        loadData(is, mySetlength_lengthrandmaxoverride);
        loadData(is, mySetlength_lengthrandmaxoptions);
        loadData(is, mySetlength_lengthrandmaxinrange);
        loadData(is, mySetlength_lengthrandmaxoutrange);
        loadData(is, mySetlength_lengthrandmaxremapramp);
        loadData(is, mySetlength_lengthrandmaxcurveattrib);
        loadData(is, mySetlength_lengthrandmaxattrib);
        loadData(is, mySetlength_lengthrandmaxtexture);
        loadData(is, mySetlength_lengthrandmaxtextureprim);
        loadData(is, mySetlength_lengthrandmaxuvmode);
        loadData(is, mySetlength_scalefactor);
        loadData(is, mySetlength_scalefactoroverride);
        loadData(is, mySetlength_scalefactoroptions);
        loadData(is, mySetlength_scalefactorinrange);
        loadData(is, mySetlength_scalefactoroutrange);
        loadData(is, mySetlength_scalefactorremapramp);
        loadData(is, mySetlength_scalefactorcurveattrib);
        loadData(is, mySetlength_scalefactorattrib);
        loadData(is, mySetlength_scalefactortexture);
        loadData(is, mySetlength_scalefactortextureprim);
        loadData(is, mySetlength_scalefactoruvmode);
        loadData(is, mySetlength_scalefactorrandmin);
        loadData(is, mySetlength_scalefactorrandminoverride);
        loadData(is, mySetlength_scalefactorrandminoptions);
        loadData(is, mySetlength_scalefactorrandmininrange);
        loadData(is, mySetlength_scalefactorrandminoutrange);
        loadData(is, mySetlength_scalefactorrandminremapramp);
        loadData(is, mySetlength_scalefactorrandmincurveattrib);
        loadData(is, mySetlength_scalefactorrandminattrib);
        loadData(is, mySetlength_scalefactorrandmintexture);
        loadData(is, mySetlength_scalefactorrandmintextureprim);
        loadData(is, mySetlength_scalefactorrandminuvmode);
        loadData(is, mySetlength_scalefactorrandmax);
        loadData(is, mySetlength_scalefactorrandmaxoverride);
        loadData(is, mySetlength_scalefactorrandmaxoptions);
        loadData(is, mySetlength_scalefactorrandmaxinrange);
        loadData(is, mySetlength_scalefactorrandmaxoutrange);
        loadData(is, mySetlength_scalefactorrandmaxremapramp);
        loadData(is, mySetlength_scalefactorrandmaxcurveattrib);
        loadData(is, mySetlength_scalefactorrandmaxattrib);
        loadData(is, mySetlength_scalefactorrandmaxtexture);
        loadData(is, mySetlength_scalefactorrandmaxtextureprim);
        loadData(is, mySetlength_scalefactorrandmaxuvmode);
        loadData(is, mySetlength_cullzerolen);
        loadData(is, mySetlength_cullthreshold);
        loadData(is, myBend_blend);
        loadData(is, myBend_axismode);
        loadData(is, myBend_axis);
        loadData(is, myBend_axiscurveattrib);
        loadData(is, myBend_axisskinattrib);
        loadData(is, myBend_dir);
        loadData(is, myBend_dircurveattrib);
        loadData(is, myBend_dirskinattrib);
        loadData(is, myBend_dirtoaxis);
        loadData(is, myBend_angle);
        loadData(is, myBend_angleoverride);
        loadData(is, myBend_angleoptions);
        loadData(is, myBend_angleinrange);
        loadData(is, myBend_angleoutrange);
        loadData(is, myBend_anglemapramptobarbs);
        loadData(is, myBend_angleremapramp);
        loadData(is, myBend_anglecurveattrib);
        loadData(is, myBend_angleattrib);
        loadData(is, myBend_angletexture);
        loadData(is, myBend_angletextureprim);
        loadData(is, myBend_angleuvmode);
        loadData(is, myBend_anglerand);
        loadData(is, myBend_anglerandoverride);
        loadData(is, myBend_anglerandoptions);
        loadData(is, myBend_anglerandinrange);
        loadData(is, myBend_anglerandoutrange);
        loadData(is, myBend_anglerandremapramp);
        loadData(is, myBend_anglerandcurveattrib);
        loadData(is, myBend_anglerandattrib);
        loadData(is, myBend_anglerandtexture);
        loadData(is, myBend_anglerandtextureprim);
        loadData(is, myBend_angleranduvmode);
        loadData(is, myBend_anglerandbias);
        loadData(is, myBend_anglerandbiasoverride);
        loadData(is, myBend_anglerandbiasoptions);
        loadData(is, myBend_anglerandbiasinrange);
        loadData(is, myBend_anglerandbiasoutrange);
        loadData(is, myBend_anglerandbiasremapramp);
        loadData(is, myBend_anglerandbiascurveattrib);
        loadData(is, myBend_anglerandbiasattrib);
        loadData(is, myBend_anglerandbiastexture);
        loadData(is, myBend_anglerandbiastextureprim);
        loadData(is, myBend_anglerandbiasuvmode);

        return true;
    }

    Geotype getGeotype() const { return Geotype(myGeotype); }
    void setGeotype(Geotype val) { myGeotype = int64(val); }
    Geotype opGeotype(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGeotype();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "geotype", cookparms.getCookTime(), 0);
        return Geotype(result);
    }
    int64 getBarbside() const { return myBarbside; }
    void setBarbside(int64 val) { myBarbside = val; }
    int64 opBarbside(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBarbside();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "barbside", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getUvattrib() const { return myUvattrib; }
    void setUvattrib(const UT_StringHolder & val) { myUvattrib = val; }
    UT_StringHolder opUvattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUvattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "uvattrib", cookparms.getCookTime(), 0);
        return result;
    }
    Grouptype getGrouptype() const { return Grouptype(myGrouptype); }
    void setGrouptype(Grouptype val) { myGrouptype = int64(val); }
    Grouptype opGrouptype(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGrouptype();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "grouptype", cookparms.getCookTime(), 0);
        return Grouptype(result);
    }
    const UT_StringHolder & getGroup() const { return myGroup; }
    void setGroup(const UT_StringHolder & val) { myGroup = val; }
    UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getSeed() const { return mySeed; }
    void setSeed(fpreal64 val) { mySeed = val; }
    fpreal64 opSeed(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSeed();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "seed", cookparms.getCookTime(), 0);
        return result;
    }
    bool getVismasks() const { return myVismasks; }
    void setVismasks(bool val) { myVismasks = val; }
    bool opVismasks(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVismasks();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "vismasks", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getBlend() const { return myBlend; }
    void setBlend(fpreal64 val) { myBlend = val; }
    fpreal64 opBlend(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBlend();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "blend", cookparms.getCookTime(), 0);
        return result;
    }
    Blendoverride getBlendoverride() const { return Blendoverride(myBlendoverride); }
    void setBlendoverride(Blendoverride val) { myBlendoverride = int64(val); }
    Blendoverride opBlendoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBlendoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "blendoverride", cookparms.getCookTime(), 0);
        return Blendoverride(result);
    }
    const UT_StringHolder & getBlendcurveattrib() const { return myBlendcurveattrib; }
    void setBlendcurveattrib(const UT_StringHolder & val) { myBlendcurveattrib = val; }
    UT_StringHolder opBlendcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBlendcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "blendcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBlendattrib() const { return myBlendattrib; }
    void setBlendattrib(const UT_StringHolder & val) { myBlendattrib = val; }
    UT_StringHolder opBlendattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBlendattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "blendattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBlendtexture() const { return myBlendtexture; }
    void setBlendtexture(const UT_StringHolder & val) { myBlendtexture = val; }
    UT_StringHolder opBlendtexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBlendtexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "blendtexture", cookparms.getCookTime(), 0);
        return result;
    }
    Op getOp() const { return Op(myOp); }
    void setOp(Op val) { myOp = int64(val); }
    Op opOp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getOp();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "op", cookparms.getCookTime(), 0);
        return Op(result);
    }
    Setlength_mode getSetlength_mode() const { return Setlength_mode(mySetlength_mode); }
    void setSetlength_mode(Setlength_mode val) { mySetlength_mode = int64(val); }
    Setlength_mode opSetlength_mode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_mode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_mode", cookparms.getCookTime(), 0);
        return Setlength_mode(result);
    }
    Setlength_method getSetlength_method() const { return Setlength_method(mySetlength_method); }
    void setSetlength_method(Setlength_method val) { mySetlength_method = int64(val); }
    Setlength_method opSetlength_method(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_method();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_method", cookparms.getCookTime(), 0);
        return Setlength_method(result);
    }
    fpreal64 getSetlength_blend() const { return mySetlength_blend; }
    void setSetlength_blend(fpreal64 val) { mySetlength_blend = val; }
    fpreal64 opSetlength_blend(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_blend();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_blend", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetlength_randomize() const { return mySetlength_randomize; }
    void setSetlength_randomize(bool val) { mySetlength_randomize = val; }
    bool opSetlength_randomize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_randomize();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setlength_randomize", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getSetlength_length() const { return mySetlength_length; }
    void setSetlength_length(fpreal64 val) { mySetlength_length = val; }
    fpreal64 opSetlength_length(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_length();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_length", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthoverride getSetlength_lengthoverride() const { return Setlength_lengthoverride(mySetlength_lengthoverride); }
    void setSetlength_lengthoverride(Setlength_lengthoverride val) { mySetlength_lengthoverride = int64(val); }
    Setlength_lengthoverride opSetlength_lengthoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthoverride", cookparms.getCookTime(), 0);
        return Setlength_lengthoverride(result);
    }
    int64 getSetlength_lengthoptions() const { return mySetlength_lengthoptions; }
    void setSetlength_lengthoptions(int64 val) { mySetlength_lengthoptions = val; }
    int64 opSetlength_lengthoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthinrange() const { return mySetlength_lengthinrange; }
    void setSetlength_lengthinrange(UT_Vector2D val) { mySetlength_lengthinrange = val; }
    UT_Vector2D opSetlength_lengthinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthoutrange() const { return mySetlength_lengthoutrange; }
    void setSetlength_lengthoutrange(UT_Vector2D val) { mySetlength_lengthoutrange = val; }
    UT_Vector2D opSetlength_lengthoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_lengthremapramp() const { return mySetlength_lengthremapramp; }
    void setSetlength_lengthremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_lengthremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_lengthremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthcurveattrib() const { return mySetlength_lengthcurveattrib; }
    void setSetlength_lengthcurveattrib(const UT_StringHolder & val) { mySetlength_lengthcurveattrib = val; }
    UT_StringHolder opSetlength_lengthcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthattrib() const { return mySetlength_lengthattrib; }
    void setSetlength_lengthattrib(const UT_StringHolder & val) { mySetlength_lengthattrib = val; }
    UT_StringHolder opSetlength_lengthattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthtexture() const { return mySetlength_lengthtexture; }
    void setSetlength_lengthtexture(const UT_StringHolder & val) { mySetlength_lengthtexture = val; }
    UT_StringHolder opSetlength_lengthtexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthtexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthtexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthtextureprim() const { return mySetlength_lengthtextureprim; }
    void setSetlength_lengthtextureprim(const UT_StringHolder & val) { mySetlength_lengthtextureprim = val; }
    UT_StringHolder opSetlength_lengthtextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthtextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthtextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthuvmode getSetlength_lengthuvmode() const { return Setlength_lengthuvmode(mySetlength_lengthuvmode); }
    void setSetlength_lengthuvmode(Setlength_lengthuvmode val) { mySetlength_lengthuvmode = int64(val); }
    Setlength_lengthuvmode opSetlength_lengthuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthuvmode", cookparms.getCookTime(), 0);
        return Setlength_lengthuvmode(result);
    }
    fpreal64 getSetlength_lengthrandmin() const { return mySetlength_lengthrandmin; }
    void setSetlength_lengthrandmin(fpreal64 val) { mySetlength_lengthrandmin = val; }
    fpreal64 opSetlength_lengthrandmin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmin();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmin", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthrandminoverride getSetlength_lengthrandminoverride() const { return Setlength_lengthrandminoverride(mySetlength_lengthrandminoverride); }
    void setSetlength_lengthrandminoverride(Setlength_lengthrandminoverride val) { mySetlength_lengthrandminoverride = int64(val); }
    Setlength_lengthrandminoverride opSetlength_lengthrandminoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminoverride", cookparms.getCookTime(), 0);
        return Setlength_lengthrandminoverride(result);
    }
    int64 getSetlength_lengthrandminoptions() const { return mySetlength_lengthrandminoptions; }
    void setSetlength_lengthrandminoptions(int64 val) { mySetlength_lengthrandminoptions = val; }
    int64 opSetlength_lengthrandminoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthrandmininrange() const { return mySetlength_lengthrandmininrange; }
    void setSetlength_lengthrandmininrange(UT_Vector2D val) { mySetlength_lengthrandmininrange = val; }
    UT_Vector2D opSetlength_lengthrandmininrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmininrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmininrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthrandminoutrange() const { return mySetlength_lengthrandminoutrange; }
    void setSetlength_lengthrandminoutrange(UT_Vector2D val) { mySetlength_lengthrandminoutrange = val; }
    UT_Vector2D opSetlength_lengthrandminoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_lengthrandminremapramp() const { return mySetlength_lengthrandminremapramp; }
    void setSetlength_lengthrandminremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_lengthrandminremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_lengthrandminremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmincurveattrib() const { return mySetlength_lengthrandmincurveattrib; }
    void setSetlength_lengthrandmincurveattrib(const UT_StringHolder & val) { mySetlength_lengthrandmincurveattrib = val; }
    UT_StringHolder opSetlength_lengthrandmincurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmincurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmincurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandminattrib() const { return mySetlength_lengthrandminattrib; }
    void setSetlength_lengthrandminattrib(const UT_StringHolder & val) { mySetlength_lengthrandminattrib = val; }
    UT_StringHolder opSetlength_lengthrandminattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmintexture() const { return mySetlength_lengthrandmintexture; }
    void setSetlength_lengthrandmintexture(const UT_StringHolder & val) { mySetlength_lengthrandmintexture = val; }
    UT_StringHolder opSetlength_lengthrandmintexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmintexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmintexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmintextureprim() const { return mySetlength_lengthrandmintextureprim; }
    void setSetlength_lengthrandmintextureprim(const UT_StringHolder & val) { mySetlength_lengthrandmintextureprim = val; }
    UT_StringHolder opSetlength_lengthrandmintextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmintextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmintextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthrandminuvmode getSetlength_lengthrandminuvmode() const { return Setlength_lengthrandminuvmode(mySetlength_lengthrandminuvmode); }
    void setSetlength_lengthrandminuvmode(Setlength_lengthrandminuvmode val) { mySetlength_lengthrandminuvmode = int64(val); }
    Setlength_lengthrandminuvmode opSetlength_lengthrandminuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandminuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandminuvmode", cookparms.getCookTime(), 0);
        return Setlength_lengthrandminuvmode(result);
    }
    fpreal64 getSetlength_lengthrandmax() const { return mySetlength_lengthrandmax; }
    void setSetlength_lengthrandmax(fpreal64 val) { mySetlength_lengthrandmax = val; }
    fpreal64 opSetlength_lengthrandmax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmax();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmax", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthrandmaxoverride getSetlength_lengthrandmaxoverride() const { return Setlength_lengthrandmaxoverride(mySetlength_lengthrandmaxoverride); }
    void setSetlength_lengthrandmaxoverride(Setlength_lengthrandmaxoverride val) { mySetlength_lengthrandmaxoverride = int64(val); }
    Setlength_lengthrandmaxoverride opSetlength_lengthrandmaxoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxoverride", cookparms.getCookTime(), 0);
        return Setlength_lengthrandmaxoverride(result);
    }
    int64 getSetlength_lengthrandmaxoptions() const { return mySetlength_lengthrandmaxoptions; }
    void setSetlength_lengthrandmaxoptions(int64 val) { mySetlength_lengthrandmaxoptions = val; }
    int64 opSetlength_lengthrandmaxoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthrandmaxinrange() const { return mySetlength_lengthrandmaxinrange; }
    void setSetlength_lengthrandmaxinrange(UT_Vector2D val) { mySetlength_lengthrandmaxinrange = val; }
    UT_Vector2D opSetlength_lengthrandmaxinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_lengthrandmaxoutrange() const { return mySetlength_lengthrandmaxoutrange; }
    void setSetlength_lengthrandmaxoutrange(UT_Vector2D val) { mySetlength_lengthrandmaxoutrange = val; }
    UT_Vector2D opSetlength_lengthrandmaxoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_lengthrandmaxremapramp() const { return mySetlength_lengthrandmaxremapramp; }
    void setSetlength_lengthrandmaxremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_lengthrandmaxremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_lengthrandmaxremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmaxcurveattrib() const { return mySetlength_lengthrandmaxcurveattrib; }
    void setSetlength_lengthrandmaxcurveattrib(const UT_StringHolder & val) { mySetlength_lengthrandmaxcurveattrib = val; }
    UT_StringHolder opSetlength_lengthrandmaxcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmaxattrib() const { return mySetlength_lengthrandmaxattrib; }
    void setSetlength_lengthrandmaxattrib(const UT_StringHolder & val) { mySetlength_lengthrandmaxattrib = val; }
    UT_StringHolder opSetlength_lengthrandmaxattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmaxtexture() const { return mySetlength_lengthrandmaxtexture; }
    void setSetlength_lengthrandmaxtexture(const UT_StringHolder & val) { mySetlength_lengthrandmaxtexture = val; }
    UT_StringHolder opSetlength_lengthrandmaxtexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxtexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxtexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_lengthrandmaxtextureprim() const { return mySetlength_lengthrandmaxtextureprim; }
    void setSetlength_lengthrandmaxtextureprim(const UT_StringHolder & val) { mySetlength_lengthrandmaxtextureprim = val; }
    UT_StringHolder opSetlength_lengthrandmaxtextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxtextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxtextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_lengthrandmaxuvmode getSetlength_lengthrandmaxuvmode() const { return Setlength_lengthrandmaxuvmode(mySetlength_lengthrandmaxuvmode); }
    void setSetlength_lengthrandmaxuvmode(Setlength_lengthrandmaxuvmode val) { mySetlength_lengthrandmaxuvmode = int64(val); }
    Setlength_lengthrandmaxuvmode opSetlength_lengthrandmaxuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_lengthrandmaxuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_lengthrandmaxuvmode", cookparms.getCookTime(), 0);
        return Setlength_lengthrandmaxuvmode(result);
    }
    fpreal64 getSetlength_scalefactor() const { return mySetlength_scalefactor; }
    void setSetlength_scalefactor(fpreal64 val) { mySetlength_scalefactor = val; }
    fpreal64 opSetlength_scalefactor(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactor();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactor", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactoroverride getSetlength_scalefactoroverride() const { return Setlength_scalefactoroverride(mySetlength_scalefactoroverride); }
    void setSetlength_scalefactoroverride(Setlength_scalefactoroverride val) { mySetlength_scalefactoroverride = int64(val); }
    Setlength_scalefactoroverride opSetlength_scalefactoroverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactoroverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactoroverride", cookparms.getCookTime(), 0);
        return Setlength_scalefactoroverride(result);
    }
    int64 getSetlength_scalefactoroptions() const { return mySetlength_scalefactoroptions; }
    void setSetlength_scalefactoroptions(int64 val) { mySetlength_scalefactoroptions = val; }
    int64 opSetlength_scalefactoroptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactoroptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactoroptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactorinrange() const { return mySetlength_scalefactorinrange; }
    void setSetlength_scalefactorinrange(UT_Vector2D val) { mySetlength_scalefactorinrange = val; }
    UT_Vector2D opSetlength_scalefactorinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactoroutrange() const { return mySetlength_scalefactoroutrange; }
    void setSetlength_scalefactoroutrange(UT_Vector2D val) { mySetlength_scalefactoroutrange = val; }
    UT_Vector2D opSetlength_scalefactoroutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactoroutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactoroutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_scalefactorremapramp() const { return mySetlength_scalefactorremapramp; }
    void setSetlength_scalefactorremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_scalefactorremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_scalefactorremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorcurveattrib() const { return mySetlength_scalefactorcurveattrib; }
    void setSetlength_scalefactorcurveattrib(const UT_StringHolder & val) { mySetlength_scalefactorcurveattrib = val; }
    UT_StringHolder opSetlength_scalefactorcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorattrib() const { return mySetlength_scalefactorattrib; }
    void setSetlength_scalefactorattrib(const UT_StringHolder & val) { mySetlength_scalefactorattrib = val; }
    UT_StringHolder opSetlength_scalefactorattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactortexture() const { return mySetlength_scalefactortexture; }
    void setSetlength_scalefactortexture(const UT_StringHolder & val) { mySetlength_scalefactortexture = val; }
    UT_StringHolder opSetlength_scalefactortexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactortexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactortexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactortextureprim() const { return mySetlength_scalefactortextureprim; }
    void setSetlength_scalefactortextureprim(const UT_StringHolder & val) { mySetlength_scalefactortextureprim = val; }
    UT_StringHolder opSetlength_scalefactortextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactortextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactortextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactoruvmode getSetlength_scalefactoruvmode() const { return Setlength_scalefactoruvmode(mySetlength_scalefactoruvmode); }
    void setSetlength_scalefactoruvmode(Setlength_scalefactoruvmode val) { mySetlength_scalefactoruvmode = int64(val); }
    Setlength_scalefactoruvmode opSetlength_scalefactoruvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactoruvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactoruvmode", cookparms.getCookTime(), 0);
        return Setlength_scalefactoruvmode(result);
    }
    fpreal64 getSetlength_scalefactorrandmin() const { return mySetlength_scalefactorrandmin; }
    void setSetlength_scalefactorrandmin(fpreal64 val) { mySetlength_scalefactorrandmin = val; }
    fpreal64 opSetlength_scalefactorrandmin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmin();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmin", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactorrandminoverride getSetlength_scalefactorrandminoverride() const { return Setlength_scalefactorrandminoverride(mySetlength_scalefactorrandminoverride); }
    void setSetlength_scalefactorrandminoverride(Setlength_scalefactorrandminoverride val) { mySetlength_scalefactorrandminoverride = int64(val); }
    Setlength_scalefactorrandminoverride opSetlength_scalefactorrandminoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminoverride", cookparms.getCookTime(), 0);
        return Setlength_scalefactorrandminoverride(result);
    }
    int64 getSetlength_scalefactorrandminoptions() const { return mySetlength_scalefactorrandminoptions; }
    void setSetlength_scalefactorrandminoptions(int64 val) { mySetlength_scalefactorrandminoptions = val; }
    int64 opSetlength_scalefactorrandminoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactorrandmininrange() const { return mySetlength_scalefactorrandmininrange; }
    void setSetlength_scalefactorrandmininrange(UT_Vector2D val) { mySetlength_scalefactorrandmininrange = val; }
    UT_Vector2D opSetlength_scalefactorrandmininrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmininrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmininrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactorrandminoutrange() const { return mySetlength_scalefactorrandminoutrange; }
    void setSetlength_scalefactorrandminoutrange(UT_Vector2D val) { mySetlength_scalefactorrandminoutrange = val; }
    UT_Vector2D opSetlength_scalefactorrandminoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_scalefactorrandminremapramp() const { return mySetlength_scalefactorrandminremapramp; }
    void setSetlength_scalefactorrandminremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_scalefactorrandminremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_scalefactorrandminremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmincurveattrib() const { return mySetlength_scalefactorrandmincurveattrib; }
    void setSetlength_scalefactorrandmincurveattrib(const UT_StringHolder & val) { mySetlength_scalefactorrandmincurveattrib = val; }
    UT_StringHolder opSetlength_scalefactorrandmincurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmincurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmincurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandminattrib() const { return mySetlength_scalefactorrandminattrib; }
    void setSetlength_scalefactorrandminattrib(const UT_StringHolder & val) { mySetlength_scalefactorrandminattrib = val; }
    UT_StringHolder opSetlength_scalefactorrandminattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmintexture() const { return mySetlength_scalefactorrandmintexture; }
    void setSetlength_scalefactorrandmintexture(const UT_StringHolder & val) { mySetlength_scalefactorrandmintexture = val; }
    UT_StringHolder opSetlength_scalefactorrandmintexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmintexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmintexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmintextureprim() const { return mySetlength_scalefactorrandmintextureprim; }
    void setSetlength_scalefactorrandmintextureprim(const UT_StringHolder & val) { mySetlength_scalefactorrandmintextureprim = val; }
    UT_StringHolder opSetlength_scalefactorrandmintextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmintextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmintextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactorrandminuvmode getSetlength_scalefactorrandminuvmode() const { return Setlength_scalefactorrandminuvmode(mySetlength_scalefactorrandminuvmode); }
    void setSetlength_scalefactorrandminuvmode(Setlength_scalefactorrandminuvmode val) { mySetlength_scalefactorrandminuvmode = int64(val); }
    Setlength_scalefactorrandminuvmode opSetlength_scalefactorrandminuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandminuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandminuvmode", cookparms.getCookTime(), 0);
        return Setlength_scalefactorrandminuvmode(result);
    }
    fpreal64 getSetlength_scalefactorrandmax() const { return mySetlength_scalefactorrandmax; }
    void setSetlength_scalefactorrandmax(fpreal64 val) { mySetlength_scalefactorrandmax = val; }
    fpreal64 opSetlength_scalefactorrandmax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmax();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmax", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactorrandmaxoverride getSetlength_scalefactorrandmaxoverride() const { return Setlength_scalefactorrandmaxoverride(mySetlength_scalefactorrandmaxoverride); }
    void setSetlength_scalefactorrandmaxoverride(Setlength_scalefactorrandmaxoverride val) { mySetlength_scalefactorrandmaxoverride = int64(val); }
    Setlength_scalefactorrandmaxoverride opSetlength_scalefactorrandmaxoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxoverride", cookparms.getCookTime(), 0);
        return Setlength_scalefactorrandmaxoverride(result);
    }
    int64 getSetlength_scalefactorrandmaxoptions() const { return mySetlength_scalefactorrandmaxoptions; }
    void setSetlength_scalefactorrandmaxoptions(int64 val) { mySetlength_scalefactorrandmaxoptions = val; }
    int64 opSetlength_scalefactorrandmaxoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactorrandmaxinrange() const { return mySetlength_scalefactorrandmaxinrange; }
    void setSetlength_scalefactorrandmaxinrange(UT_Vector2D val) { mySetlength_scalefactorrandmaxinrange = val; }
    UT_Vector2D opSetlength_scalefactorrandmaxinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getSetlength_scalefactorrandmaxoutrange() const { return mySetlength_scalefactorrandmaxoutrange; }
    void setSetlength_scalefactorrandmaxoutrange(UT_Vector2D val) { mySetlength_scalefactorrandmaxoutrange = val; }
    UT_Vector2D opSetlength_scalefactorrandmaxoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getSetlength_scalefactorrandmaxremapramp() const { return mySetlength_scalefactorrandmaxremapramp; }
    void setSetlength_scalefactorrandmaxremapramp(UT_SharedPtr<UT_Ramp> val) { mySetlength_scalefactorrandmaxremapramp = val; }
    UT_SharedPtr<UT_Ramp> opSetlength_scalefactorrandmaxremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmaxcurveattrib() const { return mySetlength_scalefactorrandmaxcurveattrib; }
    void setSetlength_scalefactorrandmaxcurveattrib(const UT_StringHolder & val) { mySetlength_scalefactorrandmaxcurveattrib = val; }
    UT_StringHolder opSetlength_scalefactorrandmaxcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmaxattrib() const { return mySetlength_scalefactorrandmaxattrib; }
    void setSetlength_scalefactorrandmaxattrib(const UT_StringHolder & val) { mySetlength_scalefactorrandmaxattrib = val; }
    UT_StringHolder opSetlength_scalefactorrandmaxattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmaxtexture() const { return mySetlength_scalefactorrandmaxtexture; }
    void setSetlength_scalefactorrandmaxtexture(const UT_StringHolder & val) { mySetlength_scalefactorrandmaxtexture = val; }
    UT_StringHolder opSetlength_scalefactorrandmaxtexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxtexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxtexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getSetlength_scalefactorrandmaxtextureprim() const { return mySetlength_scalefactorrandmaxtextureprim; }
    void setSetlength_scalefactorrandmaxtextureprim(const UT_StringHolder & val) { mySetlength_scalefactorrandmaxtextureprim = val; }
    UT_StringHolder opSetlength_scalefactorrandmaxtextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxtextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxtextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Setlength_scalefactorrandmaxuvmode getSetlength_scalefactorrandmaxuvmode() const { return Setlength_scalefactorrandmaxuvmode(mySetlength_scalefactorrandmaxuvmode); }
    void setSetlength_scalefactorrandmaxuvmode(Setlength_scalefactorrandmaxuvmode val) { mySetlength_scalefactorrandmaxuvmode = int64(val); }
    Setlength_scalefactorrandmaxuvmode opSetlength_scalefactorrandmaxuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_scalefactorrandmaxuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_scalefactorrandmaxuvmode", cookparms.getCookTime(), 0);
        return Setlength_scalefactorrandmaxuvmode(result);
    }
    bool getSetlength_cullzerolen() const { return mySetlength_cullzerolen; }
    void setSetlength_cullzerolen(bool val) { mySetlength_cullzerolen = val; }
    bool opSetlength_cullzerolen(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_cullzerolen();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setlength_cullzerolen", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getSetlength_cullthreshold() const { return mySetlength_cullthreshold; }
    void setSetlength_cullthreshold(fpreal64 val) { mySetlength_cullthreshold = val; }
    fpreal64 opSetlength_cullthreshold(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetlength_cullthreshold();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "setlength_cullthreshold", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getBend_blend() const { return myBend_blend; }
    void setBend_blend(fpreal64 val) { myBend_blend = val; }
    fpreal64 opBend_blend(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_blend();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_blend", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_axismode getBend_axismode() const { return Bend_axismode(myBend_axismode); }
    void setBend_axismode(Bend_axismode val) { myBend_axismode = int64(val); }
    Bend_axismode opBend_axismode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_axismode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_axismode", cookparms.getCookTime(), 0);
        return Bend_axismode(result);
    }
    UT_Vector3D getBend_axis() const { return myBend_axis; }
    void setBend_axis(UT_Vector3D val) { myBend_axis = val; }
    UT_Vector3D opBend_axis(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_axis();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "bend_axis", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_axiscurveattrib() const { return myBend_axiscurveattrib; }
    void setBend_axiscurveattrib(const UT_StringHolder & val) { myBend_axiscurveattrib = val; }
    UT_StringHolder opBend_axiscurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_axiscurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_axiscurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_axisskinattrib() const { return myBend_axisskinattrib; }
    void setBend_axisskinattrib(const UT_StringHolder & val) { myBend_axisskinattrib = val; }
    UT_StringHolder opBend_axisskinattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_axisskinattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_axisskinattrib", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getBend_dir() const { return myBend_dir; }
    void setBend_dir(UT_Vector3D val) { myBend_dir = val; }
    UT_Vector3D opBend_dir(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_dir();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "bend_dir", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_dircurveattrib() const { return myBend_dircurveattrib; }
    void setBend_dircurveattrib(const UT_StringHolder & val) { myBend_dircurveattrib = val; }
    UT_StringHolder opBend_dircurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_dircurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_dircurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_dirskinattrib() const { return myBend_dirskinattrib; }
    void setBend_dirskinattrib(const UT_StringHolder & val) { myBend_dirskinattrib = val; }
    UT_StringHolder opBend_dirskinattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_dirskinattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_dirskinattrib", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_dirtoaxis getBend_dirtoaxis() const { return Bend_dirtoaxis(myBend_dirtoaxis); }
    void setBend_dirtoaxis(Bend_dirtoaxis val) { myBend_dirtoaxis = int64(val); }
    Bend_dirtoaxis opBend_dirtoaxis(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_dirtoaxis();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_dirtoaxis", cookparms.getCookTime(), 0);
        return Bend_dirtoaxis(result);
    }
    fpreal64 getBend_angle() const { return myBend_angle; }
    void setBend_angle(fpreal64 val) { myBend_angle = val; }
    fpreal64 opBend_angle(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angle();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_angle", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_angleoverride getBend_angleoverride() const { return Bend_angleoverride(myBend_angleoverride); }
    void setBend_angleoverride(Bend_angleoverride val) { myBend_angleoverride = int64(val); }
    Bend_angleoverride opBend_angleoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleoverride", cookparms.getCookTime(), 0);
        return Bend_angleoverride(result);
    }
    int64 getBend_angleoptions() const { return myBend_angleoptions; }
    void setBend_angleoptions(int64 val) { myBend_angleoptions = val; }
    int64 opBend_angleoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getBend_angleinrange() const { return myBend_angleinrange; }
    void setBend_angleinrange(UT_Vector2D val) { myBend_angleinrange = val; }
    UT_Vector2D opBend_angleinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getBend_angleoutrange() const { return myBend_angleoutrange; }
    void setBend_angleoutrange(UT_Vector2D val) { myBend_angleoutrange = val; }
    UT_Vector2D opBend_angleoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    bool getBend_anglemapramptobarbs() const { return myBend_anglemapramptobarbs; }
    void setBend_anglemapramptobarbs(bool val) { myBend_anglemapramptobarbs = val; }
    bool opBend_anglemapramptobarbs(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglemapramptobarbs();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglemapramptobarbs", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getBend_angleremapramp() const { return myBend_angleremapramp; }
    void setBend_angleremapramp(UT_SharedPtr<UT_Ramp> val) { myBend_angleremapramp = val; }
    UT_SharedPtr<UT_Ramp> opBend_angleremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_anglecurveattrib() const { return myBend_anglecurveattrib; }
    void setBend_anglecurveattrib(const UT_StringHolder & val) { myBend_anglecurveattrib = val; }
    UT_StringHolder opBend_anglecurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglecurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglecurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_angleattrib() const { return myBend_angleattrib; }
    void setBend_angleattrib(const UT_StringHolder & val) { myBend_angleattrib = val; }
    UT_StringHolder opBend_angleattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_angletexture() const { return myBend_angletexture; }
    void setBend_angletexture(const UT_StringHolder & val) { myBend_angletexture = val; }
    UT_StringHolder opBend_angletexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angletexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_angletexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_angletextureprim() const { return myBend_angletextureprim; }
    void setBend_angletextureprim(const UT_StringHolder & val) { myBend_angletextureprim = val; }
    UT_StringHolder opBend_angletextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angletextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_angletextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_angleuvmode getBend_angleuvmode() const { return Bend_angleuvmode(myBend_angleuvmode); }
    void setBend_angleuvmode(Bend_angleuvmode val) { myBend_angleuvmode = int64(val); }
    Bend_angleuvmode opBend_angleuvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleuvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleuvmode", cookparms.getCookTime(), 0);
        return Bend_angleuvmode(result);
    }
    fpreal64 getBend_anglerand() const { return myBend_anglerand; }
    void setBend_anglerand(fpreal64 val) { myBend_anglerand = val; }
    fpreal64 opBend_anglerand(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerand();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerand", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_anglerandoverride getBend_anglerandoverride() const { return Bend_anglerandoverride(myBend_anglerandoverride); }
    void setBend_anglerandoverride(Bend_anglerandoverride val) { myBend_anglerandoverride = int64(val); }
    Bend_anglerandoverride opBend_anglerandoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandoverride();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandoverride", cookparms.getCookTime(), 0);
        return Bend_anglerandoverride(result);
    }
    int64 getBend_anglerandoptions() const { return myBend_anglerandoptions; }
    void setBend_anglerandoptions(int64 val) { myBend_anglerandoptions = val; }
    int64 opBend_anglerandoptions(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandoptions();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandoptions", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getBend_anglerandinrange() const { return myBend_anglerandinrange; }
    void setBend_anglerandinrange(UT_Vector2D val) { myBend_anglerandinrange = val; }
    UT_Vector2D opBend_anglerandinrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandinrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandinrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getBend_anglerandoutrange() const { return myBend_anglerandoutrange; }
    void setBend_anglerandoutrange(UT_Vector2D val) { myBend_anglerandoutrange = val; }
    UT_Vector2D opBend_anglerandoutrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandoutrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandoutrange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getBend_anglerandremapramp() const { return myBend_anglerandremapramp; }
    void setBend_anglerandremapramp(UT_SharedPtr<UT_Ramp> val) { myBend_anglerandremapramp = val; }
    UT_SharedPtr<UT_Ramp> opBend_anglerandremapramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandremapramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandremapramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_anglerandcurveattrib() const { return myBend_anglerandcurveattrib; }
    void setBend_anglerandcurveattrib(const UT_StringHolder & val) { myBend_anglerandcurveattrib = val; }
    UT_StringHolder opBend_anglerandcurveattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandcurveattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandcurveattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_anglerandattrib() const { return myBend_anglerandattrib; }
    void setBend_anglerandattrib(const UT_StringHolder & val) { myBend_anglerandattrib = val; }
    UT_StringHolder opBend_anglerandattrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandattrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_anglerandtexture() const { return myBend_anglerandtexture; }
    void setBend_anglerandtexture(const UT_StringHolder & val) { myBend_anglerandtexture = val; }
    UT_StringHolder opBend_anglerandtexture(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandtexture();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandtexture", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getBend_anglerandtextureprim() const { return myBend_anglerandtextureprim; }
    void setBend_anglerandtextureprim(const UT_StringHolder & val) { myBend_anglerandtextureprim = val; }
    UT_StringHolder opBend_anglerandtextureprim(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandtextureprim();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandtextureprim", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_angleranduvmode getBend_angleranduvmode() const { return Bend_angleranduvmode(myBend_angleranduvmode); }
    void setBend_angleranduvmode(Bend_angleranduvmode val) { myBend_angleranduvmode = int64(val); }
    Bend_angleranduvmode opBend_angleranduvmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_angleranduvmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_angleranduvmode", cookparms.getCookTime(), 0);
        return Bend_angleranduvmode(result);
    }
    fpreal64 getBend_anglerandbias() const { return myBend_anglerandbias; }
    void setBend_anglerandbias(fpreal64 val) { myBend_anglerandbias = val; }
    fpreal64 opBend_anglerandbias(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBend_anglerandbias();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "bend_anglerandbias", cookparms.getCookTime(), 0);
        return result;
    }
    Bend_anglerandbiasoverride getBend_anglerandbiasoverride() const { return Bend_anglerandbiasoverride(myBend_anglerandbiasoverride); }
    void