ht.lib = ht.lib || {};
if (!ht.lib['12345']) {
    ht.lib['12345'] = function (x, y, width, height, angle, localVarObj, localDynamicVar, nodename) {
        _ratio = GD.getRatioWithRotation(0, ratio);
        ht.lib['12345'].superClass.constructor.apply(this);
        this.localVarObj = localVarObj;
        this.localDynamicVar = localDynamicVar;
        this.childNodes = [];
        
        this._styleObject = {};
        this._originWidth = 87*_ratio.ratioX;
        this._originHeight = 59*_ratio.ratioY;
        this._baseClass = "ht.lib.12345";

        this._background = new ht.Node();
        this._background.setWidth(this._originWidth);
        this._background.setHeight(this._originHeight);
        this._background.setPosition(this._originWidth/2, this._originHeight/2);
        this._background.setImage({
            width: width,
            height: height,
            clip: true,
            comps: [
                {
                    type: 'rect',
                    background: 'rgba(0,255,0,0)',
                    rect: [0,0,width, height]
                }
            ]
        });
        this._background.__parentLib = nodename;
        this._background.isLibBackground = true;
        this.childNodes.push(this._background);
        dataModel.add(this._background);
        /*@PageBackgroundInit@*/ 
        /*@PageBeforeInit@*/
        var Lib_12345Node0points=[27, 48,27, 58],
Lib_12345Node0rect=ht.Default.unionPoint([{x:27,y:48},{x:27,y:58}]),
Lib_12345Node0compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(4.71238898038469, ratio),
    _endratio = GD.getRatioWithRotation(7.85398163397448, ratio);
for(var i=0;i<Lib_12345Node0points.length;i++){
    if(i%2==0){
        Lib_12345Node0compspts.push(Lib_12345Node0points[i]-Lib_12345Node0rect.x);
    }else{
        Lib_12345Node0compspts.push(Lib_12345Node0points[i]-Lib_12345Node0rect.y);
    } 
}

var Lib_12345Node0ptslength=Lib_12345Node0compspts.length;
if (Lib_12345Node0rect.height === 0) {
    Lib_12345Node0compspts[0] -= 0;
    Lib_12345Node0compspts[Lib_12345Node0ptslength-2] += 0;
} else if (Lib_12345Node0rect.width === 0){
    Lib_12345Node0compspts[1] -= 0;
    Lib_12345Node0compspts[Lib_12345Node0ptslength-1] += 0;
} else {
    Lib_12345Node0compspts[0] -= 0;
    Lib_12345Node0compspts[1] -= 0;
    Lib_12345Node0compspts[Lib_12345Node0ptslength-2] += 0;
    Lib_12345Node0compspts[Lib_12345Node0ptslength-1] += 0;
}

Lib_12345Node0 = new ht.Node();
Lib_12345Node0.borderWidth = 1;
Lib_12345Node0rect.width = Lib_12345Node0rect.width === 0 ? 0.0001 : Lib_12345Node0rect.width;
Lib_12345Node0rect.height = Lib_12345Node0rect.height === 0 ? 0.0001 : Lib_12345Node0rect.height;
var Lib_12345Node0endCompspts = [Lib_12345Node0compspts[Lib_12345Node0ptslength-2],Lib_12345Node0compspts[Lib_12345Node0ptslength-1],0,0];
var Lib_12345Node0startCompspts = [Lib_12345Node0compspts[0],Lib_12345Node0compspts[1],0,0];
Lib_12345Node0.setImage(GD.getPolyLineJSON());
Lib_12345Node0.setPosition(Lib_12345Node0rect.x+Lib_12345Node0rect.width/2,Lib_12345Node0rect.y+Lib_12345Node0rect.height/2);
Lib_12345Node0.setSize(Lib_12345Node0rect.width,Lib_12345Node0rect.height);
Lib_12345Node0.setStyle("opacity",1);
Lib_12345Node0.s({'pixelPerfect':true});
Lib_12345Node0borderwidth=1;
Lib_12345Node0.setRotation(0);
dataModel.add(Lib_12345Node0);

Lib_12345Node0.a('node.points',Lib_12345Node0compspts);
Lib_12345Node0.a('node.segments',[1,2]);
Lib_12345Node0.a('node.color','rgba(255,128,0,1)');
Lib_12345Node0.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node0.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node0.a('node.background','rgba(255,128,0,1)');
Lib_12345Node0.a('node.gradient','');
Lib_12345Node0.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node0.a('node.endCompspts',Lib_12345Node0endCompspts);
Lib_12345Node0.a('node.startCompspts',Lib_12345Node0startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node0';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node0, Lib_12345Node0.getImage(), Lib_12345Node0compspts, Lib_12345Node0endCompspts, Lib_12345Node0startCompspts);
var Lib_12345Node1points=[27, 58,77, 58],
Lib_12345Node1rect=ht.Default.unionPoint([{x:27,y:58},{x:77,y:58}]),
Lib_12345Node1compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.14159265358979, ratio),
    _endratio = GD.getRatioWithRotation(0, ratio);
for(var i=0;i<Lib_12345Node1points.length;i++){
    if(i%2==0){
        Lib_12345Node1compspts.push(Lib_12345Node1points[i]-Lib_12345Node1rect.x);
    }else{
        Lib_12345Node1compspts.push(Lib_12345Node1points[i]-Lib_12345Node1rect.y);
    } 
}

var Lib_12345Node1ptslength=Lib_12345Node1compspts.length;
if (Lib_12345Node1rect.height === 0) {
    Lib_12345Node1compspts[0] -= 0;
    Lib_12345Node1compspts[Lib_12345Node1ptslength-2] += 0;
} else if (Lib_12345Node1rect.width === 0){
    Lib_12345Node1compspts[1] -= 0;
    Lib_12345Node1compspts[Lib_12345Node1ptslength-1] += 0;
} else {
    Lib_12345Node1compspts[0] -= 0;
    Lib_12345Node1compspts[1] -= 0;
    Lib_12345Node1compspts[Lib_12345Node1ptslength-2] += 0;
    Lib_12345Node1compspts[Lib_12345Node1ptslength-1] += 0;
}

Lib_12345Node1 = new ht.Node();
Lib_12345Node1.borderWidth = 1;
Lib_12345Node1rect.width = Lib_12345Node1rect.width === 0 ? 0.0001 : Lib_12345Node1rect.width;
Lib_12345Node1rect.height = Lib_12345Node1rect.height === 0 ? 0.0001 : Lib_12345Node1rect.height;
var Lib_12345Node1endCompspts = [Lib_12345Node1compspts[Lib_12345Node1ptslength-2],Lib_12345Node1compspts[Lib_12345Node1ptslength-1],0,0];
var Lib_12345Node1startCompspts = [Lib_12345Node1compspts[0],Lib_12345Node1compspts[1],0,0];
Lib_12345Node1.setImage(GD.getPolyLineJSON());
Lib_12345Node1.setPosition(Lib_12345Node1rect.x+Lib_12345Node1rect.width/2,Lib_12345Node1rect.y+Lib_12345Node1rect.height/2);
Lib_12345Node1.setSize(Lib_12345Node1rect.width,Lib_12345Node1rect.height);
Lib_12345Node1.setStyle("opacity",1);
Lib_12345Node1.s({'pixelPerfect':true});
Lib_12345Node1borderwidth=1;
Lib_12345Node1.setRotation(0);
dataModel.add(Lib_12345Node1);

Lib_12345Node1.a('node.points',Lib_12345Node1compspts);
Lib_12345Node1.a('node.segments',[1,2]);
Lib_12345Node1.a('node.color','rgba(255,128,0,1)');
Lib_12345Node1.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node1.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node1.a('node.background','rgba(255,128,0,1)');
Lib_12345Node1.a('node.gradient','');
Lib_12345Node1.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node1.a('node.endCompspts',Lib_12345Node1endCompspts);
Lib_12345Node1.a('node.startCompspts',Lib_12345Node1startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node1';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node1, Lib_12345Node1.getImage(), Lib_12345Node1compspts, Lib_12345Node1endCompspts, Lib_12345Node1startCompspts);
_ratio = GD.getRatioWithRotation(0*Math.PI/180, ratio);
var Lib_12345Node2type = 'oval';
var Lib_12345Node2 = new ht.Node(),
    Lib_12345Node2BorderWidth = 1*2;

if (Lib_12345Node2type === 'arc') {
    Lib_12345Node2BorderWidth *= 1;
}

Lib_12345Node2.setImage(GD.getRectJSON(24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY, Lib_12345Node2type, '@arcFrom@', '@arcTo@', '@arcClose@'));

Lib_12345Node2.setPosition(30*ratio.ratioX, 20*ratio.ratioY);
Lib_12345Node2.setSize(24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY);
Lib_12345Node2.s({
    'pixelPerfect':true
/*@AddPara@*/
});  
Lib_12345Node2.a('node.width', 24.12698*_ratio.ratioX);
Lib_12345Node2.a('node.height', 20.63269*_ratio.ratioY);
Lib_12345Node2.a('node.type', Lib_12345Node2type);
Lib_12345Node2.a('node.rect', [0, 0, 24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY]);
Lib_12345Node2.a('node.background', 'rgba(255,255,255,0.003921569)');
Lib_12345Node2.a('node.gradientcolor', '');
Lib_12345Node2.a('node.gradient', '');
Lib_12345Node2.a('node.borderwidth', Lib_12345Node2BorderWidth);
Lib_12345Node2.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node2.a('node.fillrect', [0,0,0,0]);
Lib_12345Node2.a('node.fillbackcolor', 'rgba(0,0,0,0)');
Lib_12345Node2.a('node.fillgradientcolor', 'rgba(0,0,0,0)');
Lib_12345Node2.a('node.fillgradient', '');

if (Lib_12345Node2type !== 'rect') {
    Lib_12345Node2.a('node.arcFrom', parseFloat('@arcFrom@'));
    Lib_12345Node2.a('node.arcTo', parseFloat('@arcTo@'));
    Lib_12345Node2.a('node.arcClose', '@arcClose@' === 'true' ? true : false);
}
if (Lib_12345Node2type === 'arc') {
    Lib_12345Node2.a('node.arcOval', true);
}

Lib_12345Node2.setRotation(0*Math.PI/180);
Lib_12345Node2.borderWidth = Lib_12345Node2BorderWidth;
Lib_12345Node2.borderFillwidth = Lib_12345Node2BorderWidth;

dataModel.add(Lib_12345Node2);
Lib_12345Node2._nodename = 'Lib_12345Node2'
Lib_12345Node2._nodeType = 'rect';
zoomNodeList.push({
    node: Lib_12345Node2,
    attr: 'node.borderwidth'
});
(function (node, _img) {
    var setWidth = node.setWidth,
        setHeight = node.setHeight;

    node.setWidth = function (width) {
        if (width === this.getWidth()) return ; 
        var height = this.getHeight();

        this.a('node.width', width);
        this.a('node.rect', [0,0,width, height]);
        setWidth.apply(this, arguments);
    }
    node.setHeight = function (height) {
        if (height === this.getHeight()) return ;
        var width = this.getWidth();

        this.a('node.height', height);
        this.a('node.rect', [0,0,width, height]);
        setHeight.apply(this, arguments);
    }
})(Lib_12345Node2, Lib_12345Node2.getImage());_ratio = GD.getRatioWithRotation(0*Math.PI/180, ratio);
var Lib_12345Node3type = 'oval';
var Lib_12345Node3 = new ht.Node(),
    Lib_12345Node3BorderWidth = 1*2;

if (Lib_12345Node3type === 'arc') {
    Lib_12345Node3BorderWidth *= 1;
}

Lib_12345Node3.setImage(GD.getRectJSON(24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY, Lib_12345Node3type, '@arcFrom@', '@arcTo@', '@arcClose@'));

Lib_12345Node3.setPosition(12*ratio.ratioX, 28*ratio.ratioY);
Lib_12345Node3.setSize(24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY);
Lib_12345Node3.s({
    'pixelPerfect':true
/*@AddPara@*/
});  
Lib_12345Node3.a('node.width', 24.12698*_ratio.ratioX);
Lib_12345Node3.a('node.height', 20.63269*_ratio.ratioY);
Lib_12345Node3.a('node.type', Lib_12345Node3type);
Lib_12345Node3.a('node.rect', [0, 0, 24.12698*_ratio.ratioX, 20.63269*_ratio.ratioY]);
Lib_12345Node3.a('node.background', 'rgba(255,255,255,0.003921569)');
Lib_12345Node3.a('node.gradientcolor', '');
Lib_12345Node3.a('node.gradient', '');
Lib_12345Node3.a('node.borderwidth', Lib_12345Node3BorderWidth);
Lib_12345Node3.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node3.a('node.fillrect', [0,0,0,0]);
Lib_12345Node3.a('node.fillbackcolor', 'rgba(0,0,0,0)');
Lib_12345Node3.a('node.fillgradientcolor', 'rgba(0,0,0,0)');
Lib_12345Node3.a('node.fillgradient', '');

if (Lib_12345Node3type !== 'rect') {
    Lib_12345Node3.a('node.arcFrom', parseFloat('@arcFrom@'));
    Lib_12345Node3.a('node.arcTo', parseFloat('@arcTo@'));
    Lib_12345Node3.a('node.arcClose', '@arcClose@' === 'true' ? true : false);
}
if (Lib_12345Node3type === 'arc') {
    Lib_12345Node3.a('node.arcOval', true);
}

Lib_12345Node3.setRotation(0*Math.PI/180);
Lib_12345Node3.borderWidth = Lib_12345Node3BorderWidth;
Lib_12345Node3.borderFillwidth = Lib_12345Node3BorderWidth;

dataModel.add(Lib_12345Node3);
Lib_12345Node3._nodename = 'Lib_12345Node3'
Lib_12345Node3._nodeType = 'rect';
zoomNodeList.push({
    node: Lib_12345Node3,
    attr: 'node.borderwidth'
});
(function (node, _img) {
    var setWidth = node.setWidth,
        setHeight = node.setHeight;

    node.setWidth = function (width) {
        if (width === this.getWidth()) return ; 
        var height = this.getHeight();

        this.a('node.width', width);
        this.a('node.rect', [0,0,width, height]);
        setWidth.apply(this, arguments);
    }
    node.setHeight = function (height) {
        if (height === this.getHeight()) return ;
        var width = this.getWidth();

        this.a('node.height', height);
        this.a('node.rect', [0,0,width, height]);
        setHeight.apply(this, arguments);
    }
})(Lib_12345Node3, Lib_12345Node3.getImage());var Lib_12345Node4rect=ht.Default.unionPoint([{x: 5, y: 23},{x: 5, y: 23},{x: 14, y: 23},{x: 10, y: 33}]),
    Lib_12345Node4points=[5,23,5,23,14,23,10,33],
    Lib_12345Node4compsPoints=[],
    Lib_12345Node4SetPoints = [{x: 5, y: 23},{x: 5, y: 23},{x: 14, y: 23},{x: 10, y: 33}],
    Lib_12345Node4setSegments = [1,2,2,2];
_ratio = GD.getRatioWithRotation(1.570796, ratio);
for(var i=0;i<Lib_12345Node4points.length;i++){
    if(i%2==0){
    Lib_12345Node4compsPoints.push(Lib_12345Node4points[i]-Lib_12345Node4rect.x);
    }else{
    Lib_12345Node4compsPoints.push(Lib_12345Node4points[i]-Lib_12345Node4rect.y);
    }
}
var Lib_12345Node4 = new ht.Node();
Lib_12345Node4.setImage(GD.getPolyGonJSON());

Lib_12345Node4.setPosition(Lib_12345Node4rect.x + Lib_12345Node4rect.width/2, Lib_12345Node4rect.y + Lib_12345Node4rect.height/2);
Lib_12345Node4.setSize(Lib_12345Node4rect.width, Lib_12345Node4rect.height);
Lib_12345Node4.setRotation(1.570796);
Lib_12345Node4.borderWidth=1;
Lib_12345Node4.borderFillwidth=1*2;
Lib_12345Node4.s({'pixelPerfect':true});
dataModel.add(Lib_12345Node4);
// Lib_12345Node4.a('node.width', Lib_12345Node4rect.width*_ratio.ratioX);
// Lib_12345Node4.a('node.height', Lib_12345Node4rect.height*_ratio.ratioY);
Lib_12345Node4.a('node.clip', function(g,width,height,data) {
    var clippoints = Lib_12345Node4SetPoints;
    if(clippoints.length<=3) return;
    if(Lib_12345Node4.a('Lib_12345Node4.isFill')=="false") return;
    var clipcompsPoints=[];
    var rect = ht.Default.unionPoint(clippoints);
    for(var i=0;i<clippoints.length;i++){
        clipcompsPoints.push({x:clippoints[i].x-rect.x,y:clippoints[i].y-rect.y});
    }
    var clipsegments=Lib_12345Node4setSegments;
    g.beginPath();
    drawPoints(g,clipcompsPoints,clipsegments);
    g.clip();
})
Lib_12345Node4.a('node.type', 'shape');
Lib_12345Node4.a('node.comsPoints', Lib_12345Node4compsPoints);
Lib_12345Node4.a('node.closePath', true);
Lib_12345Node4.a('node.borderwidth', 1);
Lib_12345Node4.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node4.a('node.background','rgba(255,255,255,0.003921569)');
Lib_12345Node4.a('node.closePath', true);
Lib_12345Node4.a('node.closePath', true);
Lib_12345Node4.a('node.gradient','');
Lib_12345Node4.a('node.gradientcolor','');
Lib_12345Node4.a('node.isFill','false');
Lib_12345Node4.a('node.original',[0,0,0,0]);
Lib_12345Node4.a('node.fillrect',[0,0,0,0]);
Lib_12345Node4.a('node.fillbackcolor','rgba(255,255,255,0.003921569)');
Lib_12345Node4.a('node.fillgradient','');
Lib_12345Node4.a('node.fillgradientcolor','');
Lib_12345Node4.a('node.segments',Lib_12345Node4setSegments);
Lib_12345Node4.a('node.borderPattern',"");

(function (node, nodecompsPoints, setPoints) {
    var w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY,
        img = node.getImage();

    function resetPoints(rx, ry) {
        for (var i = 0, len = nodecompsPoints.length; i < len; i++) {
            if (i%2 === 0) {
                nodecompsPoints[i]*=rx;
            } else {
                nodecompsPoints[i]*=ry;
            }
            if (setPoints[i]) {
                setPoints[i].x *= rx;
                setPoints[i].y *= ry;
            }
        }
    }
    node.setSize(w, h);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    var position = node.getPosition();
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node._nodename = 'Lib_12345Node4';
    node._nodeType = 'polygon';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    // 重载setWidth, setHeight
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx =  width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1);
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);
    }
})(Lib_12345Node4, Lib_12345Node4compsPoints, Lib_12345Node4SetPoints );
var Lib_12345Node5points=[30, 14,30, 20],
Lib_12345Node5rect=ht.Default.unionPoint([{x:30,y:14},{x:30,y:20}]),
Lib_12345Node5compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(4.71238898038469, ratio),
    _endratio = GD.getRatioWithRotation(7.85398163397448, ratio);
for(var i=0;i<Lib_12345Node5points.length;i++){
    if(i%2==0){
        Lib_12345Node5compspts.push(Lib_12345Node5points[i]-Lib_12345Node5rect.x);
    }else{
        Lib_12345Node5compspts.push(Lib_12345Node5points[i]-Lib_12345Node5rect.y);
    } 
}

var Lib_12345Node5ptslength=Lib_12345Node5compspts.length;
if (Lib_12345Node5rect.height === 0) {
    Lib_12345Node5compspts[0] -= 0;
    Lib_12345Node5compspts[Lib_12345Node5ptslength-2] += 0;
} else if (Lib_12345Node5rect.width === 0){
    Lib_12345Node5compspts[1] -= 0;
    Lib_12345Node5compspts[Lib_12345Node5ptslength-1] += 0;
} else {
    Lib_12345Node5compspts[0] -= 0;
    Lib_12345Node5compspts[1] -= 0;
    Lib_12345Node5compspts[Lib_12345Node5ptslength-2] += 0;
    Lib_12345Node5compspts[Lib_12345Node5ptslength-1] += 0;
}

Lib_12345Node5 = new ht.Node();
Lib_12345Node5.borderWidth = 1;
Lib_12345Node5rect.width = Lib_12345Node5rect.width === 0 ? 0.0001 : Lib_12345Node5rect.width;
Lib_12345Node5rect.height = Lib_12345Node5rect.height === 0 ? 0.0001 : Lib_12345Node5rect.height;
var Lib_12345Node5endCompspts = [Lib_12345Node5compspts[Lib_12345Node5ptslength-2],Lib_12345Node5compspts[Lib_12345Node5ptslength-1],0,0];
var Lib_12345Node5startCompspts = [Lib_12345Node5compspts[0],Lib_12345Node5compspts[1],0,0];
Lib_12345Node5.setImage(GD.getPolyLineJSON());
Lib_12345Node5.setPosition(Lib_12345Node5rect.x+Lib_12345Node5rect.width/2,Lib_12345Node5rect.y+Lib_12345Node5rect.height/2);
Lib_12345Node5.setSize(Lib_12345Node5rect.width,Lib_12345Node5rect.height);
Lib_12345Node5.setStyle("opacity",1);
Lib_12345Node5.s({'pixelPerfect':true});
Lib_12345Node5borderwidth=1;
Lib_12345Node5.setRotation(0);
dataModel.add(Lib_12345Node5);

Lib_12345Node5.a('node.points',Lib_12345Node5compspts);
Lib_12345Node5.a('node.segments',[1,2]);
Lib_12345Node5.a('node.color','rgba(255,128,0,1)');
Lib_12345Node5.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node5.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node5.a('node.background','rgba(255,128,0,1)');
Lib_12345Node5.a('node.gradient','');
Lib_12345Node5.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node5.a('node.endCompspts',Lib_12345Node5endCompspts);
Lib_12345Node5.a('node.startCompspts',Lib_12345Node5startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node5';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node5, Lib_12345Node5.getImage(), Lib_12345Node5compspts, Lib_12345Node5endCompspts, Lib_12345Node5startCompspts);
var Lib_12345Node6points=[30, 20,36, 24],
Lib_12345Node6rect=ht.Default.unionPoint([{x:30,y:20},{x:36,y:24}]),
Lib_12345Node6compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.72959527089228, ratio),
    _endratio = GD.getRatioWithRotation(0.588002617302485, ratio);
for(var i=0;i<Lib_12345Node6points.length;i++){
    if(i%2==0){
        Lib_12345Node6compspts.push(Lib_12345Node6points[i]-Lib_12345Node6rect.x);
    }else{
        Lib_12345Node6compspts.push(Lib_12345Node6points[i]-Lib_12345Node6rect.y);
    } 
}

var Lib_12345Node6ptslength=Lib_12345Node6compspts.length;
if (Lib_12345Node6rect.height === 0) {
    Lib_12345Node6compspts[0] -= 0;
    Lib_12345Node6compspts[Lib_12345Node6ptslength-2] += 0;
} else if (Lib_12345Node6rect.width === 0){
    Lib_12345Node6compspts[1] -= 0;
    Lib_12345Node6compspts[Lib_12345Node6ptslength-1] += 0;
} else {
    Lib_12345Node6compspts[0] -= 0;
    Lib_12345Node6compspts[1] -= 0;
    Lib_12345Node6compspts[Lib_12345Node6ptslength-2] += 0;
    Lib_12345Node6compspts[Lib_12345Node6ptslength-1] += 0;
}

Lib_12345Node6 = new ht.Node();
Lib_12345Node6.borderWidth = 1;
Lib_12345Node6rect.width = Lib_12345Node6rect.width === 0 ? 0.0001 : Lib_12345Node6rect.width;
Lib_12345Node6rect.height = Lib_12345Node6rect.height === 0 ? 0.0001 : Lib_12345Node6rect.height;
var Lib_12345Node6endCompspts = [Lib_12345Node6compspts[Lib_12345Node6ptslength-2],Lib_12345Node6compspts[Lib_12345Node6ptslength-1],0,0];
var Lib_12345Node6startCompspts = [Lib_12345Node6compspts[0],Lib_12345Node6compspts[1],0,0];
Lib_12345Node6.setImage(GD.getPolyLineJSON());
Lib_12345Node6.setPosition(Lib_12345Node6rect.x+Lib_12345Node6rect.width/2,Lib_12345Node6rect.y+Lib_12345Node6rect.height/2);
Lib_12345Node6.setSize(Lib_12345Node6rect.width,Lib_12345Node6rect.height);
Lib_12345Node6.setStyle("opacity",1);
Lib_12345Node6.s({'pixelPerfect':true});
Lib_12345Node6borderwidth=1;
Lib_12345Node6.setRotation(0);
dataModel.add(Lib_12345Node6);

Lib_12345Node6.a('node.points',Lib_12345Node6compspts);
Lib_12345Node6.a('node.segments',[1,2]);
Lib_12345Node6.a('node.color','rgba(255,128,0,1)');
Lib_12345Node6.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node6.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node6.a('node.background','rgba(255,128,0,1)');
Lib_12345Node6.a('node.gradient','');
Lib_12345Node6.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node6.a('node.endCompspts',Lib_12345Node6endCompspts);
Lib_12345Node6.a('node.startCompspts',Lib_12345Node6startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node6';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node6, Lib_12345Node6.getImage(), Lib_12345Node6compspts, Lib_12345Node6endCompspts, Lib_12345Node6startCompspts);
var Lib_12345Node7points=[30, 20,24, 24],
Lib_12345Node7rect=ht.Default.unionPoint([{x:30,y:20},{x:24,y:24}]),
Lib_12345Node7compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(-0.588002617302485, ratio),
    _endratio = GD.getRatioWithRotation(2.55359003628731, ratio);
for(var i=0;i<Lib_12345Node7points.length;i++){
    if(i%2==0){
        Lib_12345Node7compspts.push(Lib_12345Node7points[i]-Lib_12345Node7rect.x);
    }else{
        Lib_12345Node7compspts.push(Lib_12345Node7points[i]-Lib_12345Node7rect.y);
    } 
}

var Lib_12345Node7ptslength=Lib_12345Node7compspts.length;
if (Lib_12345Node7rect.height === 0) {
    Lib_12345Node7compspts[0] -= 0;
    Lib_12345Node7compspts[Lib_12345Node7ptslength-2] += 0;
} else if (Lib_12345Node7rect.width === 0){
    Lib_12345Node7compspts[1] -= 0;
    Lib_12345Node7compspts[Lib_12345Node7ptslength-1] += 0;
} else {
    Lib_12345Node7compspts[0] -= 0;
    Lib_12345Node7compspts[1] -= 0;
    Lib_12345Node7compspts[Lib_12345Node7ptslength-2] += 0;
    Lib_12345Node7compspts[Lib_12345Node7ptslength-1] += 0;
}

Lib_12345Node7 = new ht.Node();
Lib_12345Node7.borderWidth = 1;
Lib_12345Node7rect.width = Lib_12345Node7rect.width === 0 ? 0.0001 : Lib_12345Node7rect.width;
Lib_12345Node7rect.height = Lib_12345Node7rect.height === 0 ? 0.0001 : Lib_12345Node7rect.height;
var Lib_12345Node7endCompspts = [Lib_12345Node7compspts[Lib_12345Node7ptslength-2],Lib_12345Node7compspts[Lib_12345Node7ptslength-1],0,0];
var Lib_12345Node7startCompspts = [Lib_12345Node7compspts[0],Lib_12345Node7compspts[1],0,0];
Lib_12345Node7.setImage(GD.getPolyLineJSON());
Lib_12345Node7.setPosition(Lib_12345Node7rect.x+Lib_12345Node7rect.width/2,Lib_12345Node7rect.y+Lib_12345Node7rect.height/2);
Lib_12345Node7.setSize(Lib_12345Node7rect.width,Lib_12345Node7rect.height);
Lib_12345Node7.setStyle("opacity",1);
Lib_12345Node7.s({'pixelPerfect':true});
Lib_12345Node7borderwidth=1;
Lib_12345Node7.setRotation(0);
dataModel.add(Lib_12345Node7);

Lib_12345Node7.a('node.points',Lib_12345Node7compspts);
Lib_12345Node7.a('node.segments',[1,2]);
Lib_12345Node7.a('node.color','rgba(255,128,0,1)');
Lib_12345Node7.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node7.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node7.a('node.background','rgba(255,128,0,1)');
Lib_12345Node7.a('node.gradient','');
Lib_12345Node7.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node7.a('node.endCompspts',Lib_12345Node7endCompspts);
Lib_12345Node7.a('node.startCompspts',Lib_12345Node7startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node7';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node7, Lib_12345Node7.getImage(), Lib_12345Node7compspts, Lib_12345Node7endCompspts, Lib_12345Node7startCompspts);
_ratio = GD.getRatioWithRotation(0*Math.PI/180, ratio);
var Lib_12345Node8type = 'oval';
var Lib_12345Node8 = new ht.Node(),
    Lib_12345Node8BorderWidth = 1*2;

if (Lib_12345Node8type === 'arc') {
    Lib_12345Node8BorderWidth *= 1;
}

Lib_12345Node8.setImage(GD.getRectJSON(24.12697*_ratio.ratioX, 20.63269*_ratio.ratioY, Lib_12345Node8type, '@arcFrom@', '@arcTo@', '@arcClose@'));

Lib_12345Node8.setPosition(29*ratio.ratioX, 36*ratio.ratioY);
Lib_12345Node8.setSize(24.12697*_ratio.ratioX, 20.63269*_ratio.ratioY);
Lib_12345Node8.s({
    'pixelPerfect':true
/*@AddPara@*/
});  
Lib_12345Node8.a('node.width', 24.12697*_ratio.ratioX);
Lib_12345Node8.a('node.height', 20.63269*_ratio.ratioY);
Lib_12345Node8.a('node.type', Lib_12345Node8type);
Lib_12345Node8.a('node.rect', [0, 0, 24.12697*_ratio.ratioX, 20.63269*_ratio.ratioY]);
Lib_12345Node8.a('node.background', 'rgba(255,255,255,0.003921569)');
Lib_12345Node8.a('node.gradientcolor', '');
Lib_12345Node8.a('node.gradient', '');
Lib_12345Node8.a('node.borderwidth', Lib_12345Node8BorderWidth);
Lib_12345Node8.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node8.a('node.fillrect', [0,0,0,0]);
Lib_12345Node8.a('node.fillbackcolor', 'rgba(0,0,0,0)');
Lib_12345Node8.a('node.fillgradientcolor', 'rgba(0,0,0,0)');
Lib_12345Node8.a('node.fillgradient', '');

if (Lib_12345Node8type !== 'rect') {
    Lib_12345Node8.a('node.arcFrom', parseFloat('@arcFrom@'));
    Lib_12345Node8.a('node.arcTo', parseFloat('@arcTo@'));
    Lib_12345Node8.a('node.arcClose', '@arcClose@' === 'true' ? true : false);
}
if (Lib_12345Node8type === 'arc') {
    Lib_12345Node8.a('node.arcOval', true);
}

Lib_12345Node8.setRotation(0*Math.PI/180);
Lib_12345Node8.borderWidth = Lib_12345Node8BorderWidth;
Lib_12345Node8.borderFillwidth = Lib_12345Node8BorderWidth;

dataModel.add(Lib_12345Node8);
Lib_12345Node8._nodename = 'Lib_12345Node8'
Lib_12345Node8._nodeType = 'rect';
zoomNodeList.push({
    node: Lib_12345Node8,
    attr: 'node.borderwidth'
});
(function (node, _img) {
    var setWidth = node.setWidth,
        setHeight = node.setHeight;

    node.setWidth = function (width) {
        if (width === this.getWidth()) return ; 
        var height = this.getHeight();

        this.a('node.width', width);
        this.a('node.rect', [0,0,width, height]);
        setWidth.apply(this, arguments);
    }
    node.setHeight = function (height) {
        if (height === this.getHeight()) return ;
        var width = this.getWidth();

        this.a('node.height', height);
        this.a('node.rect', [0,0,width, height]);
        setHeight.apply(this, arguments);
    }
})(Lib_12345Node8, Lib_12345Node8.getImage());var Lib_12345Node9points=[29, 30,29, 36],
Lib_12345Node9rect=ht.Default.unionPoint([{x:29,y:30},{x:29,y:36}]),
Lib_12345Node9compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(4.71238898038469, ratio),
    _endratio = GD.getRatioWithRotation(7.85398163397448, ratio);
for(var i=0;i<Lib_12345Node9points.length;i++){
    if(i%2==0){
        Lib_12345Node9compspts.push(Lib_12345Node9points[i]-Lib_12345Node9rect.x);
    }else{
        Lib_12345Node9compspts.push(Lib_12345Node9points[i]-Lib_12345Node9rect.y);
    } 
}

var Lib_12345Node9ptslength=Lib_12345Node9compspts.length;
if (Lib_12345Node9rect.height === 0) {
    Lib_12345Node9compspts[0] -= 0;
    Lib_12345Node9compspts[Lib_12345Node9ptslength-2] += 0;
} else if (Lib_12345Node9rect.width === 0){
    Lib_12345Node9compspts[1] -= 0;
    Lib_12345Node9compspts[Lib_12345Node9ptslength-1] += 0;
} else {
    Lib_12345Node9compspts[0] -= 0;
    Lib_12345Node9compspts[1] -= 0;
    Lib_12345Node9compspts[Lib_12345Node9ptslength-2] += 0;
    Lib_12345Node9compspts[Lib_12345Node9ptslength-1] += 0;
}

Lib_12345Node9 = new ht.Node();
Lib_12345Node9.borderWidth = 1;
Lib_12345Node9rect.width = Lib_12345Node9rect.width === 0 ? 0.0001 : Lib_12345Node9rect.width;
Lib_12345Node9rect.height = Lib_12345Node9rect.height === 0 ? 0.0001 : Lib_12345Node9rect.height;
var Lib_12345Node9endCompspts = [Lib_12345Node9compspts[Lib_12345Node9ptslength-2],Lib_12345Node9compspts[Lib_12345Node9ptslength-1],0,0];
var Lib_12345Node9startCompspts = [Lib_12345Node9compspts[0],Lib_12345Node9compspts[1],0,0];
Lib_12345Node9.setImage(GD.getPolyLineJSON());
Lib_12345Node9.setPosition(Lib_12345Node9rect.x+Lib_12345Node9rect.width/2,Lib_12345Node9rect.y+Lib_12345Node9rect.height/2);
Lib_12345Node9.setSize(Lib_12345Node9rect.width,Lib_12345Node9rect.height);
Lib_12345Node9.setStyle("opacity",1);
Lib_12345Node9.s({'pixelPerfect':true});
Lib_12345Node9borderwidth=1;
Lib_12345Node9.setRotation(0);
dataModel.add(Lib_12345Node9);

Lib_12345Node9.a('node.points',Lib_12345Node9compspts);
Lib_12345Node9.a('node.segments',[1,2]);
Lib_12345Node9.a('node.color','rgba(255,128,0,1)');
Lib_12345Node9.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node9.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node9.a('node.background','rgba(255,128,0,1)');
Lib_12345Node9.a('node.gradient','');
Lib_12345Node9.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node9.a('node.endCompspts',Lib_12345Node9endCompspts);
Lib_12345Node9.a('node.startCompspts',Lib_12345Node9startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node9';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node9, Lib_12345Node9.getImage(), Lib_12345Node9compspts, Lib_12345Node9endCompspts, Lib_12345Node9startCompspts);
var Lib_12345Node10points=[29, 36,35, 41],
Lib_12345Node10rect=ht.Default.unionPoint([{x:29,y:36},{x:35,y:41}]),
Lib_12345Node10compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.83633091806099, ratio),
    _endratio = GD.getRatioWithRotation(0.694738264471199, ratio);
for(var i=0;i<Lib_12345Node10points.length;i++){
    if(i%2==0){
        Lib_12345Node10compspts.push(Lib_12345Node10points[i]-Lib_12345Node10rect.x);
    }else{
        Lib_12345Node10compspts.push(Lib_12345Node10points[i]-Lib_12345Node10rect.y);
    } 
}

var Lib_12345Node10ptslength=Lib_12345Node10compspts.length;
if (Lib_12345Node10rect.height === 0) {
    Lib_12345Node10compspts[0] -= 0;
    Lib_12345Node10compspts[Lib_12345Node10ptslength-2] += 0;
} else if (Lib_12345Node10rect.width === 0){
    Lib_12345Node10compspts[1] -= 0;
    Lib_12345Node10compspts[Lib_12345Node10ptslength-1] += 0;
} else {
    Lib_12345Node10compspts[0] -= 0;
    Lib_12345Node10compspts[1] -= 0;
    Lib_12345Node10compspts[Lib_12345Node10ptslength-2] += 0;
    Lib_12345Node10compspts[Lib_12345Node10ptslength-1] += 0;
}

Lib_12345Node10 = new ht.Node();
Lib_12345Node10.borderWidth = 1;
Lib_12345Node10rect.width = Lib_12345Node10rect.width === 0 ? 0.0001 : Lib_12345Node10rect.width;
Lib_12345Node10rect.height = Lib_12345Node10rect.height === 0 ? 0.0001 : Lib_12345Node10rect.height;
var Lib_12345Node10endCompspts = [Lib_12345Node10compspts[Lib_12345Node10ptslength-2],Lib_12345Node10compspts[Lib_12345Node10ptslength-1],0,0];
var Lib_12345Node10startCompspts = [Lib_12345Node10compspts[0],Lib_12345Node10compspts[1],0,0];
Lib_12345Node10.setImage(GD.getPolyLineJSON());
Lib_12345Node10.setPosition(Lib_12345Node10rect.x+Lib_12345Node10rect.width/2,Lib_12345Node10rect.y+Lib_12345Node10rect.height/2);
Lib_12345Node10.setSize(Lib_12345Node10rect.width,Lib_12345Node10rect.height);
Lib_12345Node10.setStyle("opacity",1);
Lib_12345Node10.s({'pixelPerfect':true});
Lib_12345Node10borderwidth=1;
Lib_12345Node10.setRotation(0);
dataModel.add(Lib_12345Node10);

Lib_12345Node10.a('node.points',Lib_12345Node10compspts);
Lib_12345Node10.a('node.segments',[1,2]);
Lib_12345Node10.a('node.color','rgba(255,128,0,1)');
Lib_12345Node10.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node10.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node10.a('node.background','rgba(255,128,0,1)');
Lib_12345Node10.a('node.gradient','');
Lib_12345Node10.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node10.a('node.endCompspts',Lib_12345Node10endCompspts);
Lib_12345Node10.a('node.startCompspts',Lib_12345Node10startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node10';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node10, Lib_12345Node10.getImage(), Lib_12345Node10compspts, Lib_12345Node10endCompspts, Lib_12345Node10startCompspts);
var Lib_12345Node11points=[29, 36,23, 41],
Lib_12345Node11rect=ht.Default.unionPoint([{x:29,y:36},{x:23,y:41}]),
Lib_12345Node11compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(-0.694738264471199, ratio),
    _endratio = GD.getRatioWithRotation(2.44685438911859, ratio);
for(var i=0;i<Lib_12345Node11points.length;i++){
    if(i%2==0){
        Lib_12345Node11compspts.push(Lib_12345Node11points[i]-Lib_12345Node11rect.x);
    }else{
        Lib_12345Node11compspts.push(Lib_12345Node11points[i]-Lib_12345Node11rect.y);
    } 
}

var Lib_12345Node11ptslength=Lib_12345Node11compspts.length;
if (Lib_12345Node11rect.height === 0) {
    Lib_12345Node11compspts[0] -= 0;
    Lib_12345Node11compspts[Lib_12345Node11ptslength-2] += 0;
} else if (Lib_12345Node11rect.width === 0){
    Lib_12345Node11compspts[1] -= 0;
    Lib_12345Node11compspts[Lib_12345Node11ptslength-1] += 0;
} else {
    Lib_12345Node11compspts[0] -= 0;
    Lib_12345Node11compspts[1] -= 0;
    Lib_12345Node11compspts[Lib_12345Node11ptslength-2] += 0;
    Lib_12345Node11compspts[Lib_12345Node11ptslength-1] += 0;
}

Lib_12345Node11 = new ht.Node();
Lib_12345Node11.borderWidth = 1;
Lib_12345Node11rect.width = Lib_12345Node11rect.width === 0 ? 0.0001 : Lib_12345Node11rect.width;
Lib_12345Node11rect.height = Lib_12345Node11rect.height === 0 ? 0.0001 : Lib_12345Node11rect.height;
var Lib_12345Node11endCompspts = [Lib_12345Node11compspts[Lib_12345Node11ptslength-2],Lib_12345Node11compspts[Lib_12345Node11ptslength-1],0,0];
var Lib_12345Node11startCompspts = [Lib_12345Node11compspts[0],Lib_12345Node11compspts[1],0,0];
Lib_12345Node11.setImage(GD.getPolyLineJSON());
Lib_12345Node11.setPosition(Lib_12345Node11rect.x+Lib_12345Node11rect.width/2,Lib_12345Node11rect.y+Lib_12345Node11rect.height/2);
Lib_12345Node11.setSize(Lib_12345Node11rect.width,Lib_12345Node11rect.height);
Lib_12345Node11.setStyle("opacity",1);
Lib_12345Node11.s({'pixelPerfect':true});
Lib_12345Node11borderwidth=1;
Lib_12345Node11.setRotation(0);
dataModel.add(Lib_12345Node11);

Lib_12345Node11.a('node.points',Lib_12345Node11compspts);
Lib_12345Node11.a('node.segments',[1,2]);
Lib_12345Node11.a('node.color','rgba(255,128,0,1)');
Lib_12345Node11.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node11.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node11.a('node.background','rgba(255,128,0,1)');
Lib_12345Node11.a('node.gradient','');
Lib_12345Node11.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node11.a('node.endCompspts',Lib_12345Node11endCompspts);
Lib_12345Node11.a('node.startCompspts',Lib_12345Node11startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node11';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node11, Lib_12345Node11.getImage(), Lib_12345Node11compspts, Lib_12345Node11endCompspts, Lib_12345Node11startCompspts);
_ratio = GD.getRatioWithRotation(0*Math.PI/180, ratio);
var Lib_12345Node12_0type = 'rect';
var Lib_12345Node12_0 = new ht.Node(),
    Lib_12345Node12_0BorderWidth = 1*2;

if (Lib_12345Node12_0type === 'arc') {
    Lib_12345Node12_0BorderWidth *= 1;
}

Lib_12345Node12_0.setImage(GD.getRectJSON(15.36963*_ratio.ratioX, 25.91444*_ratio.ratioY, Lib_12345Node12_0type, '@arcFrom@', '@arcTo@', '@arcClose@'));

Lib_12345Node12_0.setPosition(76*ratio.ratioX, 29*ratio.ratioY);
Lib_12345Node12_0.setSize(15.36963*_ratio.ratioX, 25.91444*_ratio.ratioY);
Lib_12345Node12_0.s({
    'pixelPerfect':true
/*@AddPara@*/
});  
Lib_12345Node12_0.a('node.width', 15.36963*_ratio.ratioX);
Lib_12345Node12_0.a('node.height', 25.91444*_ratio.ratioY);
Lib_12345Node12_0.a('node.type', Lib_12345Node12_0type);
Lib_12345Node12_0.a('node.rect', [0, 0, 15.36963*_ratio.ratioX, 25.91444*_ratio.ratioY]);
Lib_12345Node12_0.a('node.background', 'rgba(255,255,255,0.003921569)');
Lib_12345Node12_0.a('node.gradientcolor', '');
Lib_12345Node12_0.a('node.gradient', '');
Lib_12345Node12_0.a('node.borderwidth', Lib_12345Node12_0BorderWidth);
Lib_12345Node12_0.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node12_0.a('node.fillrect', [0,0,0,0]);
Lib_12345Node12_0.a('node.fillbackcolor', 'rgba(0,0,0,0)');
Lib_12345Node12_0.a('node.fillgradientcolor', 'rgba(0,0,0,0)');
Lib_12345Node12_0.a('node.fillgradient', '');

if (Lib_12345Node12_0type !== 'rect') {
    Lib_12345Node12_0.a('node.arcFrom', parseFloat('@arcFrom@'));
    Lib_12345Node12_0.a('node.arcTo', parseFloat('@arcTo@'));
    Lib_12345Node12_0.a('node.arcClose', '@arcClose@' === 'true' ? true : false);
}
if (Lib_12345Node12_0type === 'arc') {
    Lib_12345Node12_0.a('node.arcOval', true);
}

Lib_12345Node12_0.setRotation(0*Math.PI/180);
Lib_12345Node12_0.borderWidth = Lib_12345Node12_0BorderWidth;
Lib_12345Node12_0.borderFillwidth = Lib_12345Node12_0BorderWidth;

dataModel.add(Lib_12345Node12_0);
Lib_12345Node12_0._nodename = 'Lib_12345Node12_0'
Lib_12345Node12_0._nodeType = 'rect';
zoomNodeList.push({
    node: Lib_12345Node12_0,
    attr: 'node.borderwidth'
});
(function (node, _img) {
    var setWidth = node.setWidth,
        setHeight = node.setHeight;

    node.setWidth = function (width) {
        if (width === this.getWidth()) return ; 
        var height = this.getHeight();

        this.a('node.width', width);
        this.a('node.rect', [0,0,width, height]);
        setWidth.apply(this, arguments);
    }
    node.setHeight = function (height) {
        if (height === this.getHeight()) return ;
        var width = this.getWidth();

        this.a('node.height', height);
        this.a('node.rect', [0,0,width, height]);
        setHeight.apply(this, arguments);
    }
})(Lib_12345Node12_0, Lib_12345Node12_0.getImage());var Lib_12345Node12_1points=[76, 42,76, 51],
Lib_12345Node12_1rect=ht.Default.unionPoint([{x:76,y:42},{x:76,y:51}]),
Lib_12345Node12_1compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(4.71238898038469, ratio),
    _endratio = GD.getRatioWithRotation(7.85398163397448, ratio);
for(var i=0;i<Lib_12345Node12_1points.length;i++){
    if(i%2==0){
        Lib_12345Node12_1compspts.push(Lib_12345Node12_1points[i]-Lib_12345Node12_1rect.x);
    }else{
        Lib_12345Node12_1compspts.push(Lib_12345Node12_1points[i]-Lib_12345Node12_1rect.y);
    } 
}

var Lib_12345Node12_1ptslength=Lib_12345Node12_1compspts.length;
if (Lib_12345Node12_1rect.height === 0) {
    Lib_12345Node12_1compspts[0] -= 0;
    Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-2] += 0;
} else if (Lib_12345Node12_1rect.width === 0){
    Lib_12345Node12_1compspts[1] -= 0;
    Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-1] += 0;
} else {
    Lib_12345Node12_1compspts[0] -= 0;
    Lib_12345Node12_1compspts[1] -= 0;
    Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-2] += 0;
    Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-1] += 0;
}

Lib_12345Node12_1 = new ht.Node();
Lib_12345Node12_1.borderWidth = 1;
Lib_12345Node12_1rect.width = Lib_12345Node12_1rect.width === 0 ? 0.0001 : Lib_12345Node12_1rect.width;
Lib_12345Node12_1rect.height = Lib_12345Node12_1rect.height === 0 ? 0.0001 : Lib_12345Node12_1rect.height;
var Lib_12345Node12_1endCompspts = [Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-2],Lib_12345Node12_1compspts[Lib_12345Node12_1ptslength-1],0,0];
var Lib_12345Node12_1startCompspts = [Lib_12345Node12_1compspts[0],Lib_12345Node12_1compspts[1],0,0];
Lib_12345Node12_1.setImage(GD.getPolyLineJSON());
Lib_12345Node12_1.setPosition(Lib_12345Node12_1rect.x+Lib_12345Node12_1rect.width/2,Lib_12345Node12_1rect.y+Lib_12345Node12_1rect.height/2);
Lib_12345Node12_1.setSize(Lib_12345Node12_1rect.width,Lib_12345Node12_1rect.height);
Lib_12345Node12_1.setStyle("opacity",1);
Lib_12345Node12_1.s({'pixelPerfect':true});
Lib_12345Node12_1borderwidth=1;
Lib_12345Node12_1.setRotation(0);
dataModel.add(Lib_12345Node12_1);

Lib_12345Node12_1.a('node.points',Lib_12345Node12_1compspts);
Lib_12345Node12_1.a('node.segments',[1,2]);
Lib_12345Node12_1.a('node.color','rgba(255,128,0,1)');
Lib_12345Node12_1.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node12_1.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node12_1.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_1.a('node.gradient','');
Lib_12345Node12_1.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_1.a('node.endCompspts',Lib_12345Node12_1endCompspts);
Lib_12345Node12_1.a('node.startCompspts',Lib_12345Node12_1startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node12_1';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node12_1, Lib_12345Node12_1.getImage(), Lib_12345Node12_1compspts, Lib_12345Node12_1endCompspts, Lib_12345Node12_1startCompspts);
var Lib_12345Node12_2points=[76, 0,76, 28],
Lib_12345Node12_2rect=ht.Default.unionPoint([{x:76,y:0},{x:76,y:28}]),
Lib_12345Node12_2compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(4.71238898038469, ratio),
    _endratio = GD.getRatioWithRotation(7.85398163397448, ratio);
for(var i=0;i<Lib_12345Node12_2points.length;i++){
    if(i%2==0){
        Lib_12345Node12_2compspts.push(Lib_12345Node12_2points[i]-Lib_12345Node12_2rect.x);
    }else{
        Lib_12345Node12_2compspts.push(Lib_12345Node12_2points[i]-Lib_12345Node12_2rect.y);
    } 
}

var Lib_12345Node12_2ptslength=Lib_12345Node12_2compspts.length;
if (Lib_12345Node12_2rect.height === 0) {
    Lib_12345Node12_2compspts[0] -= 0;
    Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-2] += 0;
} else if (Lib_12345Node12_2rect.width === 0){
    Lib_12345Node12_2compspts[1] -= 0;
    Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-1] += 0;
} else {
    Lib_12345Node12_2compspts[0] -= 0;
    Lib_12345Node12_2compspts[1] -= 0;
    Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-2] += 0;
    Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-1] += 0;
}

Lib_12345Node12_2 = new ht.Node();
Lib_12345Node12_2.borderWidth = 1;
Lib_12345Node12_2rect.width = Lib_12345Node12_2rect.width === 0 ? 0.0001 : Lib_12345Node12_2rect.width;
Lib_12345Node12_2rect.height = Lib_12345Node12_2rect.height === 0 ? 0.0001 : Lib_12345Node12_2rect.height;
var Lib_12345Node12_2endCompspts = [Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-2],Lib_12345Node12_2compspts[Lib_12345Node12_2ptslength-1],0,0];
var Lib_12345Node12_2startCompspts = [Lib_12345Node12_2compspts[0],Lib_12345Node12_2compspts[1],0,0];
Lib_12345Node12_2.setImage(GD.getPolyLineJSON());
Lib_12345Node12_2.setPosition(Lib_12345Node12_2rect.x+Lib_12345Node12_2rect.width/2,Lib_12345Node12_2rect.y+Lib_12345Node12_2rect.height/2);
Lib_12345Node12_2.setSize(Lib_12345Node12_2rect.width,Lib_12345Node12_2rect.height);
Lib_12345Node12_2.setStyle("opacity",1);
Lib_12345Node12_2.s({'pixelPerfect':true});
Lib_12345Node12_2borderwidth=1;
Lib_12345Node12_2.setRotation(0);
dataModel.add(Lib_12345Node12_2);

Lib_12345Node12_2.a('node.points',Lib_12345Node12_2compspts);
Lib_12345Node12_2.a('node.segments',[1,2]);
Lib_12345Node12_2.a('node.color','rgba(255,128,0,1)');
Lib_12345Node12_2.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node12_2.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node12_2.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_2.a('node.gradient','');
Lib_12345Node12_2.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_2.a('node.endCompspts',Lib_12345Node12_2endCompspts);
Lib_12345Node12_2.a('node.startCompspts',Lib_12345Node12_2startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node12_2';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node12_2, Lib_12345Node12_2.getImage(), Lib_12345Node12_2compspts, Lib_12345Node12_2endCompspts, Lib_12345Node12_2startCompspts);
var Lib_12345Node12_3rect=ht.Default.unionPoint([{x: 71, y: 21},{x: 71, y: 21},{x: 80, y: 21},{x: 76, y: 29}]),
    Lib_12345Node12_3points=[71,21,71,21,80,21,76,29],
    Lib_12345Node12_3compsPoints=[],
    Lib_12345Node12_3SetPoints = [{x: 71, y: 21},{x: 71, y: 21},{x: 80, y: 21},{x: 76, y: 29}],
    Lib_12345Node12_3setSegments = [1,2,2,2];
_ratio = GD.getRatioWithRotation(0, ratio);
for(var i=0;i<Lib_12345Node12_3points.length;i++){
    if(i%2==0){
    Lib_12345Node12_3compsPoints.push(Lib_12345Node12_3points[i]-Lib_12345Node12_3rect.x);
    }else{
    Lib_12345Node12_3compsPoints.push(Lib_12345Node12_3points[i]-Lib_12345Node12_3rect.y);
    }
}
var Lib_12345Node12_3 = new ht.Node();
Lib_12345Node12_3.setImage(GD.getPolyGonJSON());

Lib_12345Node12_3.setPosition(Lib_12345Node12_3rect.x + Lib_12345Node12_3rect.width/2, Lib_12345Node12_3rect.y + Lib_12345Node12_3rect.height/2);
Lib_12345Node12_3.setSize(Lib_12345Node12_3rect.width, Lib_12345Node12_3rect.height);
Lib_12345Node12_3.setRotation(0);
Lib_12345Node12_3.borderWidth=1;
Lib_12345Node12_3.borderFillwidth=1*2;
Lib_12345Node12_3.s({'pixelPerfect':true});
dataModel.add(Lib_12345Node12_3);
// Lib_12345Node12_3.a('node.width', Lib_12345Node12_3rect.width*_ratio.ratioX);
// Lib_12345Node12_3.a('node.height', Lib_12345Node12_3rect.height*_ratio.ratioY);
Lib_12345Node12_3.a('node.clip', function(g,width,height,data) {
    var clippoints = Lib_12345Node12_3SetPoints;
    if(clippoints.length<=3) return;
    if(Lib_12345Node12_3.a('Lib_12345Node12_3.isFill')=="false") return;
    var clipcompsPoints=[];
    var rect = ht.Default.unionPoint(clippoints);
    for(var i=0;i<clippoints.length;i++){
        clipcompsPoints.push({x:clippoints[i].x-rect.x,y:clippoints[i].y-rect.y});
    }
    var clipsegments=Lib_12345Node12_3setSegments;
    g.beginPath();
    drawPoints(g,clipcompsPoints,clipsegments);
    g.clip();
})
Lib_12345Node12_3.a('node.type', 'shape');
Lib_12345Node12_3.a('node.comsPoints', Lib_12345Node12_3compsPoints);
Lib_12345Node12_3.a('node.closePath', true);
Lib_12345Node12_3.a('node.borderwidth', 1);
Lib_12345Node12_3.a('node.color', 'rgba(255,128,0,1)');
Lib_12345Node12_3.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_3.a('node.closePath', true);
Lib_12345Node12_3.a('node.closePath', true);
Lib_12345Node12_3.a('node.gradient','');
Lib_12345Node12_3.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_3.a('node.isFill','false');
Lib_12345Node12_3.a('node.original',[0,0,0,0]);
Lib_12345Node12_3.a('node.fillrect',[0,0,0,0]);
Lib_12345Node12_3.a('node.fillbackcolor','rgba(255,128,0,1)');
Lib_12345Node12_3.a('node.fillgradient','');
Lib_12345Node12_3.a('node.fillgradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_3.a('node.segments',Lib_12345Node12_3setSegments);
Lib_12345Node12_3.a('node.borderPattern',"");

(function (node, nodecompsPoints, setPoints) {
    var w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY,
        img = node.getImage();

    function resetPoints(rx, ry) {
        for (var i = 0, len = nodecompsPoints.length; i < len; i++) {
            if (i%2 === 0) {
                nodecompsPoints[i]*=rx;
            } else {
                nodecompsPoints[i]*=ry;
            }
            if (setPoints[i]) {
                setPoints[i].x *= rx;
                setPoints[i].y *= ry;
            }
        }
    }
    node.setSize(w, h);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    var position = node.getPosition();
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node._nodename = 'Lib_12345Node12_3';
    node._nodeType = 'polygon';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    // 重载setWidth, setHeight
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx =  width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1);
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);
    }
})(Lib_12345Node12_3, Lib_12345Node12_3compsPoints, Lib_12345Node12_3SetPoints );
var Lib_12345Node12_4points=[72, 56,80, 56],
Lib_12345Node12_4rect=ht.Default.unionPoint([{x:72,y:56},{x:80,y:56}]),
Lib_12345Node12_4compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.14159265358979, ratio),
    _endratio = GD.getRatioWithRotation(0, ratio);
for(var i=0;i<Lib_12345Node12_4points.length;i++){
    if(i%2==0){
        Lib_12345Node12_4compspts.push(Lib_12345Node12_4points[i]-Lib_12345Node12_4rect.x);
    }else{
        Lib_12345Node12_4compspts.push(Lib_12345Node12_4points[i]-Lib_12345Node12_4rect.y);
    } 
}

var Lib_12345Node12_4ptslength=Lib_12345Node12_4compspts.length;
if (Lib_12345Node12_4rect.height === 0) {
    Lib_12345Node12_4compspts[0] -= 0;
    Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-2] += 0;
} else if (Lib_12345Node12_4rect.width === 0){
    Lib_12345Node12_4compspts[1] -= 0;
    Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-1] += 0;
} else {
    Lib_12345Node12_4compspts[0] -= 0;
    Lib_12345Node12_4compspts[1] -= 0;
    Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-2] += 0;
    Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-1] += 0;
}

Lib_12345Node12_4 = new ht.Node();
Lib_12345Node12_4.borderWidth = 1;
Lib_12345Node12_4rect.width = Lib_12345Node12_4rect.width === 0 ? 0.0001 : Lib_12345Node12_4rect.width;
Lib_12345Node12_4rect.height = Lib_12345Node12_4rect.height === 0 ? 0.0001 : Lib_12345Node12_4rect.height;
var Lib_12345Node12_4endCompspts = [Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-2],Lib_12345Node12_4compspts[Lib_12345Node12_4ptslength-1],0,0];
var Lib_12345Node12_4startCompspts = [Lib_12345Node12_4compspts[0],Lib_12345Node12_4compspts[1],0,0];
Lib_12345Node12_4.setImage(GD.getPolyLineJSON());
Lib_12345Node12_4.setPosition(Lib_12345Node12_4rect.x+Lib_12345Node12_4rect.width/2,Lib_12345Node12_4rect.y+Lib_12345Node12_4rect.height/2);
Lib_12345Node12_4.setSize(Lib_12345Node12_4rect.width,Lib_12345Node12_4rect.height);
Lib_12345Node12_4.setStyle("opacity",1);
Lib_12345Node12_4.s({'pixelPerfect':true});
Lib_12345Node12_4borderwidth=1;
Lib_12345Node12_4.setRotation(0);
dataModel.add(Lib_12345Node12_4);

Lib_12345Node12_4.a('node.points',Lib_12345Node12_4compspts);
Lib_12345Node12_4.a('node.segments',[1,2]);
Lib_12345Node12_4.a('node.color','rgba(255,128,0,1)');
Lib_12345Node12_4.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node12_4.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node12_4.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_4.a('node.gradient','');
Lib_12345Node12_4.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_4.a('node.endCompspts',Lib_12345Node12_4endCompspts);
Lib_12345Node12_4.a('node.startCompspts',Lib_12345Node12_4startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node12_4';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node12_4, Lib_12345Node12_4.getImage(), Lib_12345Node12_4compspts, Lib_12345Node12_4endCompspts, Lib_12345Node12_4startCompspts);
var Lib_12345Node12_5points=[68, 53,83, 53],
Lib_12345Node12_5rect=ht.Default.unionPoint([{x:68,y:53},{x:83,y:53}]),
Lib_12345Node12_5compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.14159265358979, ratio),
    _endratio = GD.getRatioWithRotation(0, ratio);
for(var i=0;i<Lib_12345Node12_5points.length;i++){
    if(i%2==0){
        Lib_12345Node12_5compspts.push(Lib_12345Node12_5points[i]-Lib_12345Node12_5rect.x);
    }else{
        Lib_12345Node12_5compspts.push(Lib_12345Node12_5points[i]-Lib_12345Node12_5rect.y);
    } 
}

var Lib_12345Node12_5ptslength=Lib_12345Node12_5compspts.length;
if (Lib_12345Node12_5rect.height === 0) {
    Lib_12345Node12_5compspts[0] -= 0;
    Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-2] += 0;
} else if (Lib_12345Node12_5rect.width === 0){
    Lib_12345Node12_5compspts[1] -= 0;
    Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-1] += 0;
} else {
    Lib_12345Node12_5compspts[0] -= 0;
    Lib_12345Node12_5compspts[1] -= 0;
    Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-2] += 0;
    Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-1] += 0;
}

Lib_12345Node12_5 = new ht.Node();
Lib_12345Node12_5.borderWidth = 1;
Lib_12345Node12_5rect.width = Lib_12345Node12_5rect.width === 0 ? 0.0001 : Lib_12345Node12_5rect.width;
Lib_12345Node12_5rect.height = Lib_12345Node12_5rect.height === 0 ? 0.0001 : Lib_12345Node12_5rect.height;
var Lib_12345Node12_5endCompspts = [Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-2],Lib_12345Node12_5compspts[Lib_12345Node12_5ptslength-1],0,0];
var Lib_12345Node12_5startCompspts = [Lib_12345Node12_5compspts[0],Lib_12345Node12_5compspts[1],0,0];
Lib_12345Node12_5.setImage(GD.getPolyLineJSON());
Lib_12345Node12_5.setPosition(Lib_12345Node12_5rect.x+Lib_12345Node12_5rect.width/2,Lib_12345Node12_5rect.y+Lib_12345Node12_5rect.height/2);
Lib_12345Node12_5.setSize(Lib_12345Node12_5rect.width,Lib_12345Node12_5rect.height);
Lib_12345Node12_5.setStyle("opacity",1);
Lib_12345Node12_5.s({'pixelPerfect':true});
Lib_12345Node12_5borderwidth=1;
Lib_12345Node12_5.setRotation(0);
dataModel.add(Lib_12345Node12_5);

Lib_12345Node12_5.a('node.points',Lib_12345Node12_5compspts);
Lib_12345Node12_5.a('node.segments',[1,2]);
Lib_12345Node12_5.a('node.color','rgba(255,128,0,1)');
Lib_12345Node12_5.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node12_5.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node12_5.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_5.a('node.gradient','');
Lib_12345Node12_5.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_5.a('node.endCompspts',Lib_12345Node12_5endCompspts);
Lib_12345Node12_5.a('node.startCompspts',Lib_12345Node12_5startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node12_5';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node12_5, Lib_12345Node12_5.getImage(), Lib_12345Node12_5compspts, Lib_12345Node12_5endCompspts, Lib_12345Node12_5startCompspts);
var Lib_12345Node12_6points=[67, 50,86, 50],
Lib_12345Node12_6rect=ht.Default.unionPoint([{x:67,y:50},{x:86,y:50}]),
Lib_12345Node12_6compspts=[];
_ratio = GD.getRatioWithRotation(0, ratio);
var _startratio = GD.getRatioWithRotation(3.14159265358979, ratio),
    _endratio = GD.getRatioWithRotation(0, ratio);
for(var i=0;i<Lib_12345Node12_6points.length;i++){
    if(i%2==0){
        Lib_12345Node12_6compspts.push(Lib_12345Node12_6points[i]-Lib_12345Node12_6rect.x);
    }else{
        Lib_12345Node12_6compspts.push(Lib_12345Node12_6points[i]-Lib_12345Node12_6rect.y);
    } 
}

var Lib_12345Node12_6ptslength=Lib_12345Node12_6compspts.length;
if (Lib_12345Node12_6rect.height === 0) {
    Lib_12345Node12_6compspts[0] -= 0;
    Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-2] += 0;
} else if (Lib_12345Node12_6rect.width === 0){
    Lib_12345Node12_6compspts[1] -= 0;
    Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-1] += 0;
} else {
    Lib_12345Node12_6compspts[0] -= 0;
    Lib_12345Node12_6compspts[1] -= 0;
    Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-2] += 0;
    Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-1] += 0;
}

Lib_12345Node12_6 = new ht.Node();
Lib_12345Node12_6.borderWidth = 1;
Lib_12345Node12_6rect.width = Lib_12345Node12_6rect.width === 0 ? 0.0001 : Lib_12345Node12_6rect.width;
Lib_12345Node12_6rect.height = Lib_12345Node12_6rect.height === 0 ? 0.0001 : Lib_12345Node12_6rect.height;
var Lib_12345Node12_6endCompspts = [Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-2],Lib_12345Node12_6compspts[Lib_12345Node12_6ptslength-1],0,0];
var Lib_12345Node12_6startCompspts = [Lib_12345Node12_6compspts[0],Lib_12345Node12_6compspts[1],0,0];
Lib_12345Node12_6.setImage(GD.getPolyLineJSON());
Lib_12345Node12_6.setPosition(Lib_12345Node12_6rect.x+Lib_12345Node12_6rect.width/2,Lib_12345Node12_6rect.y+Lib_12345Node12_6rect.height/2);
Lib_12345Node12_6.setSize(Lib_12345Node12_6rect.width,Lib_12345Node12_6rect.height);
Lib_12345Node12_6.setStyle("opacity",1);
Lib_12345Node12_6.s({'pixelPerfect':true});
Lib_12345Node12_6borderwidth=1;
Lib_12345Node12_6.setRotation(0);
dataModel.add(Lib_12345Node12_6);

Lib_12345Node12_6.a('node.points',Lib_12345Node12_6compspts);
Lib_12345Node12_6.a('node.segments',[1,2]);
Lib_12345Node12_6.a('node.color','rgba(255,128,0,1)');
Lib_12345Node12_6.a('node.borderPattern',getDashStyle("@borderPattern@"));
Lib_12345Node12_6.a('node.borderColor','rgba(255,128,0,1)');

Lib_12345Node12_6.a('node.background','rgba(255,128,0,1)');
Lib_12345Node12_6.a('node.gradient','');
Lib_12345Node12_6.a('node.gradientcolor','rgba(255,128,0,1)');
Lib_12345Node12_6.a('node.endCompspts',Lib_12345Node12_6endCompspts);
Lib_12345Node12_6.a('node.startCompspts',Lib_12345Node12_6startCompspts);

(function (node, img, compspts, endCompspts, startCompspts) {
    var position = node.getPosition(),
        w = node.getWidth()*_ratio.ratioX,
        h = node.getHeight()*_ratio.ratioY;
    function resetPoints(rx, ry) {
        for (var i = 0, len = compspts.length; i < len; i++) {
            if (i%2 === 0) {
                compspts[i]*=rx;
            } else {
                compspts[i]*=ry;
            }
        }
        endCompspts[0] = compspts[compspts.length-2];
        endCompspts[1] = compspts[compspts.length-1];
        endCompspts[2] *= rx;
        endCompspts[3] *= ry;
        node.a('node.offsetEndY', -(endCompspts[3]*0.5));
        node.a('node.offsetEndX', -(endCompspts[2]*0.5));
        
        startCompspts[0] = compspts[0];
        startCompspts[1] = compspts[1];
        startCompspts[2] *= rx;
        startCompspts[3] *= ry;
        node.a('node.offsetStartY', -(startCompspts[3]*0.5));
        node.a('node.offsetStartX', -(startCompspts[2]*0.5));
        node.a('node.endRotation', GD.calcRotationByStartAndEnd(compspts[i-4], compspts[i-3], compspts[i-2], compspts[i-1]));
        node.a('node.startRotation', GD.calcRotationByStartAndEnd(compspts[0], compspts[1], compspts[2], compspts[3]) + Math.PI);
    }
    node.setSize(w, h);
    node.setPosition(position.x * ratio.ratioX, position.y * ratio.ratioY);
    node.a('node.width', w);
    node.a('node.height', h);
    resetPoints(_ratio.ratioX, _ratio.ratioY);
    node.borderWidth = 1;
    node.a('node.borderwidth',node.borderWidth);
    node._nodename = 'Lib_12345Node12_6';
    node._nodeType = 'line';
    zoomNodeList.push({
        node: node,
        attr: 'node.borderwidth'
    });
    var setWidth = node.setWidth,
        setHeight = node.setHeight,
        timer, rx = 1, ry = 1;
   
    node.setWidth = function (width) {
        var _width = this.getWidth();
        rx = width / _width;
        node.a('node.width', width);
        setWidth.apply(this, arguments);
            resetPoints(rx, 1); 
    }
    node.setHeight = function (height) {
        var _height = this.getHeight();
        ry = height / _height;
        node.a('node.height', height);
        setHeight.apply(this, arguments);
            resetPoints(1, ry);  
    }
})(Lib_12345Node12_6, Lib_12345Node12_6.getImage(), Lib_12345Node12_6compspts, Lib_12345Node12_6endCompspts, Lib_12345Node12_6startCompspts);
_ratio = GD.getRatioWithRotation(0*Math.PI/180, ratio);
var Lib_12345Node12boundtype = 'rect';
var Lib_12345Node12bound = new ht.Node(),
    Lib_12345Node12boundBorderWidth = 0*2;

if (Lib_12345Node12boundtype === 'arc') {
    Lib_12345Node12boundBorderWidth *= 0;
}

Lib_12345Node12bound.setImage(GD.getRectJSON(19.12164*_ratio.ratioX, 55.61331*_ratio.ratioY, Lib_12345Node12boundtype, '@arcFrom@', '@arcTo@', '@arcClose@'));

Lib_12345Node12bound.setPosition(76*ratio.ratioX, 28*ratio.ratioY);
Lib_12345Node12bound.setSize(19.12164*_ratio.ratioX, 55.61331*_ratio.ratioY);
Lib_12345Node12bound.s({
    'pixelPerfect':true
/*@AddPara@*/
});  
Lib_12345Node12bound.a('node.width', 19.12164*_ratio.ratioX);
Lib_12345Node12bound.a('node.height', 55.61331*_ratio.ratioY);
Lib_12345Node12bound.a('node.type', Lib_12345Node12boundtype);
Lib_12345Node12bound.a('node.rect', [0, 0, 19.12164*_ratio.ratioX, 55.61331*_ratio.ratioY]);
Lib_12345Node12bound.a('node.background', 'rgba(255,255,255,0.003921569)');
Lib_12345Node12bound.a('node.gradientcolor', '');
Lib_12345Node12bound.a('node.gradient', '');
Lib_12345Node12bound.a('node.borderwidth', Lib_12345Node12boundBorderWidth);
Lib_12345Node12bound.a('node.color', 'rgba(0,0,0,1)');
Lib_12345Node12bound.a('node.fillrect', [0,0,0,0]);
Lib_12345Node12bound.a('node.fillbackcolor', 'rgba(0,0,0,0)');
Lib_12345Node12bound.a('node.fillgradientcolor', 'rgba(0,0,0,0)');
Lib_12345Node12bound.a('node.fillgradient', '');

if (Lib_12345Node12boundtype !== 'rect') {
    Lib_12345Node12bound.a('node.arcFrom', parseFloat('@arcFrom@'));
    Lib_12345Node12bound.a('node.arcTo', parseFloat('@arcTo@'));
    Lib_12345Node12bound.a('node.arcClose', '@arcClose@' === 'true' ? true : false);
}
if (Lib_12345Node12boundtype === 'arc') {
    Lib_12345Node12bound.a('node.arcOval', true);
}

Lib_12345Node12bound.setRotation(0*Math.PI/180);
Lib_12345Node12bound.borderWidth = Lib_12345Node12boundBorderWidth;
Lib_12345Node12bound.borderFillwidth = Lib_12345Node12boundBorderWidth;

dataModel.add(Lib_12345Node12bound);
Lib_12345Node12bound._nodename = 'Lib_12345Node12bound'
Lib_12345Node12bound._nodeType = 'rect';
zoomNodeList.push({
    node: Lib_12345Node12bound,
    attr: 'node.borderwidth'
});
(function (node, _img) {
    var setWidth = node.setWidth,
        setHeight = node.setHeight;

    node.setWidth = function (width) {
        if (width === this.getWidth()) return ; 
        var height = this.getHeight();

        this.a('node.width', width);
        this.a('node.rect', [0,0,width, height]);
        setWidth.apply(this, arguments);
    }
    node.setHeight = function (height) {
        if (height === this.getHeight()) return ;
        var width = this.getWidth();

        this.a('node.height', height);
        this.a('node.rect', [0,0,width, height]);
        setHeight.apply(this, arguments);
    }
})(Lib_12345Node12bound, Lib_12345Node12bound.getImage());
/*@GraphList@*/
        GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_0, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_1, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_2, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_3, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_4, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_5, (180 )*Math.PI/180, ratio);
GD.groupRotat(Lib_12345Node12bound, Lib_12345Node12_6, (180 )*Math.PI/180, ratio);
/*@PageInit@*/
        
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

        this['Lib_12345Node0'] = Lib_12345Node0; 
 Lib_12345Node0.__parentLib = nodename; 
 Lib_12345Node0.__parent = this; 
  this.childNodes.push(Lib_12345Node0); 
this['Lib_12345Node1'] = Lib_12345Node1; 
 Lib_12345Node1.__parentLib = nodename; 
 Lib_12345Node1.__parent = this; 
  this.childNodes.push(Lib_12345Node1); 
this['Lib_12345Node2'] = Lib_12345Node2; 
 Lib_12345Node2.__parentLib = nodename; 
 Lib_12345Node2.__parent = this; 
  this.childNodes.push(Lib_12345Node2); 
this['Lib_12345Node3'] = Lib_12345Node3; 
 Lib_12345Node3.__parentLib = nodename; 
 Lib_12345Node3.__parent = this; 
  this.childNodes.push(Lib_12345Node3); 
this['Lib_12345Node4'] = Lib_12345Node4; 
 Lib_12345Node4.__parentLib = nodename; 
 Lib_12345Node4.__parent = this; 
  this.childNodes.push(Lib_12345Node4); 
this['Lib_12345Node5'] = Lib_12345Node5; 
 Lib_12345Node5.__parentLib = nodename; 
 Lib_12345Node5.__parent = this; 
  this.childNodes.push(Lib_12345Node5); 
this['Lib_12345Node6'] = Lib_12345Node6; 
 Lib_12345Node6.__parentLib = nodename; 
 Lib_12345Node6.__parent = this; 
  this.childNodes.push(Lib_12345Node6); 
this['Lib_12345Node7'] = Lib_12345Node7; 
 Lib_12345Node7.__parentLib = nodename; 
 Lib_12345Node7.__parent = this; 
  this.childNodes.push(Lib_12345Node7); 
this['Lib_12345Node8'] = Lib_12345Node8; 
 Lib_12345Node8.__parentLib = nodename; 
 Lib_12345Node8.__parent = this; 
  this.childNodes.push(Lib_12345Node8); 
this['Lib_12345Node9'] = Lib_12345Node9; 
 Lib_12345Node9.__parentLib = nodename; 
 Lib_12345Node9.__parent = this; 
  this.childNodes.push(Lib_12345Node9); 
this['Lib_12345Node10'] = Lib_12345Node10; 
 Lib_12345Node10.__parentLib = nodename; 
 Lib_12345Node10.__parent = this; 
  this.childNodes.push(Lib_12345Node10); 
this['Lib_12345Node11'] = Lib_12345Node11; 
 Lib_12345Node11.__parentLib = nodename; 
 Lib_12345Node11.__parent = this; 
  this.childNodes.push(Lib_12345Node11); 
this['Lib_12345Node12_0'] = Lib_12345Node12_0; 
 Lib_12345Node12_0.__parentLib = nodename; 
 Lib_12345Node12_0.__parent = this; 
  this.childNodes.push(Lib_12345Node12_0); 
this['Lib_12345Node12_1'] = Lib_12345Node12_1; 
 Lib_12345Node12_1.__parentLib = nodename; 
 Lib_12345Node12_1.__parent = this; 
  this.childNodes.push(Lib_12345Node12_1); 
this['Lib_12345Node12_2'] = Lib_12345Node12_2; 
 Lib_12345Node12_2.__parentLib = nodename; 
 Lib_12345Node12_2.__parent = this; 
  this.childNodes.push(Lib_12345Node12_2); 
this['Lib_12345Node12_3'] = Lib_12345Node12_3; 
 Lib_12345Node12_3.__parentLib = nodename; 
 Lib_12345Node12_3.__parent = this; 
  this.childNodes.push(Lib_12345Node12_3); 
this['Lib_12345Node12_4'] = Lib_12345Node12_4; 
 Lib_12345Node12_4.__parentLib = nodename; 
 Lib_12345Node12_4.__parent = this; 
  this.childNodes.push(Lib_12345Node12_4); 
this['Lib_12345Node12_5'] = Lib_12345Node12_5; 
 Lib_12345Node12_5.__parentLib = nodename; 
 Lib_12345Node12_5.__parent = this; 
  this.childNodes.push(Lib_12345Node12_5); 
this['Lib_12345Node12_6'] = Lib_12345Node12_6; 
 Lib_12345Node12_6.__parentLib = nodename; 
 Lib_12345Node12_6.__parent = this; 
  this.childNodes.push(Lib_12345Node12_6); 
this['Lib_12345Node12bound'] = Lib_12345Node12bound; 
 Lib_12345Node12bound.__parentLib = nodename; 
 Lib_12345Node12bound.__parent = this; 
  this.childNodes.push(Lib_12345Node12bound); 

        /*@ControlContextMenu@*/
        /*@Declare@*/
        this.init(x, y, width, height, angle);
    };
    ht.Default.def('ht.lib.12345', Object, {
        refresh10ms: function () {
    
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

    var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

    /*@refresh10ms@*/
},
refresh100ms: function () {
    
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

    var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

    /*@refresh100ms@*/
},
refresh500ms: function () {
    
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

    var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

    /*@refresh500ms@*/
},
refresh1s: function () {
    var Counter1s = arguments[0] || 0;
    
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

    var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

    /*@refresh1s@*/
},
refresh5s: function () {
    
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

    var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

    /*@refresh5s@*/
},

/*@PageDynamic@*/
        onEvent: function (e, data, type, origin, offset, objMouseOn, ctm) {
            
 var localVarObj = this.localVarObj; 
 var localDynamicVarObj = this.localDynamicVar(); 

            var Lib_12345Node0= this.Lib_12345Node0; 
var Lib_12345Node1= this.Lib_12345Node1; 
var Lib_12345Node2= this.Lib_12345Node2; 
var Lib_12345Node3= this.Lib_12345Node3; 
var Lib_12345Node4= this.Lib_12345Node4; 
var Lib_12345Node5= this.Lib_12345Node5; 
var Lib_12345Node6= this.Lib_12345Node6; 
var Lib_12345Node7= this.Lib_12345Node7; 
var Lib_12345Node8= this.Lib_12345Node8; 
var Lib_12345Node9= this.Lib_12345Node9; 
var Lib_12345Node10= this.Lib_12345Node10; 
var Lib_12345Node11= this.Lib_12345Node11; 
var Lib_12345Node12_0= this.Lib_12345Node12_0; 
var Lib_12345Node12_1= this.Lib_12345Node12_1; 
var Lib_12345Node12_2= this.Lib_12345Node12_2; 
var Lib_12345Node12_3= this.Lib_12345Node12_3; 
var Lib_12345Node12_4= this.Lib_12345Node12_4; 
var Lib_12345Node12_5= this.Lib_12345Node12_5; 
var Lib_12345Node12_6= this.Lib_12345Node12_6; 
var Lib_12345Node12bound= this.Lib_12345Node12bound; 

            
if (type === 'click') {
    /*@EvnentClicked@*/
} else if (type === 'mousedown') {
    mouseX=e.clientX;
    mouseY=e.clientY;
    /*@EvnentMouseDown@*/
} else if (type === 'mouseup') {
    /*@EvnentMouseUp@*/
} else if (type === 'mousemove') {
    var mouseX, mouseY, position, zoom;
    position=origin.getLogicalPoint(e);
    zoom = graphView.getZoom();
    if (origin === graphView) {
        mouseX= position.x + origin.tx();
        mouseY = position.y + origin.ty();
    } else {
        offset = offset || {x: 0, y: 0};
        mouseX = position.x / zoom + offset.x + origin.tx();
        mouseY = position.y / zoom + offset.y + origin.ty();
    }
    /*@EvnentMouseLeave@*/

    /*@EvnentMouseOver@*/
} else if (type === 'keydown') {
    /*@EvnentKeyDown@*/ 
} else if (type === 'contextmenu') {
    /*@Declare@*/
    /*@SetNodeContextMenu@*/
    /*@SetPageContextMenu@*/
}
/*@LibEvent@*/
        },
        getBaseClass: function () {
            return this._baseClass;
        },
        getWidth: function () {
            return this._width;
        },
        getHeight: function () {
            return this._height;
        },
        getSize: function () {
            return {
                width: this._width,
                height: this._height
            }
        },
        setWidth: function (width) {
            if (width === undefined || width === null || width != width) {
                return ;
            }
            var originWidth = this._width;
            var ratio = width / originWidth;
            var childNodes = this.childNodes, childNode, p, op = this.getPosition(), w, cw, ox, rotation = this.getRotation();
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                p = childNode.getPosition();
                cw = childNode.getWidth();
                    w = cw >=2 ? cw * ratio : cw;
                    childNode.setWidth(w);
                ox = op.x + (p.x - op.x) * ratio;
                childNode.setPosition(ox, p.y);

                rotation = GD.calcRotation(rotation);
                if (rotation === 0 || rotation === Math.PI) {
                    // 图元未旋转
                    ox = op.x + (p.x - op.x)*ratio;
                    childNode.setPosition(ox, p.y);
                } else if (rotation === 90 * Math.PI / 180) {
                    // 图元旋转以后
                    ox = op.y + (p.y - op.y)*ratio;
                    childNode.setPosition(p.x, ox);
                }
            }
            this._width = width;
            this._originWidth = width;
            this._ratioX = ratio;
            return this;
        },
        setHeight: function (height) {
            if (height === undefined || height === null || height != height) {
                return ;
            }
            var originHeight = this._height;
            var ratio = height / originHeight;
            var childNodes = this.childNodes, childNode, p, op = this.getPosition(), h, ch, oy, rotation = this.getRotation();
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                p = childNode.getPosition();
                ch = childNode.getHeight();

                h = ch >=2 ? ch * ratio : ch;
                childNode.setHeight(h);
                
                rotation = GD.calcRotation(rotation);

                if (rotation === 0 || rotation === Math.PI) {
                    // 图元未旋转
                    oy = op.y + (p.y - op.y)*ratio;
                    childNode.setPosition(p.x, oy);
                } else if (rotation === 90 * Math.PI / 180) {
                    // 图元旋转以后
                    oy = op.x + (p.x - op.x)*ratio;
                    childNode.setPosition(oy, p.y);
                }
            }
            this._height = height;
            this._originHeight = height;
            this._ratioY = ratio;
            return this;
        },
        setSize: function (size) {
            // var args = Array.prototype.slice.call(arguments, 0);
            // var height, width;
            // if (args.length === 0) {
            //     return ;
            // }else if (args.length === 1) {
            //     height = args[0].height;
            //     width = args[0].width;
            // } else {
            //     width = args[0];
            //     height = args[1];
            // }
            // var wh = GD.getRatioWithRotation(angle, wid)
            // this.setHeight(height);
            // this.setWidth(width);
            // return this;

            var args = Array.prototype.slice.call(arguments, 0);
            var height, width;
            if (args.length === 0) {
                return ;
            }else if (args.length === 1) {
                height = args[0].height;
                width = args[0].width;
                angle = 0;
            } else if (args.length === 2) {
                if (typeof args[0] === 'object') {
                    width = args[0].width;
                    height = args[0].height;
                    angle = args[1] || 0;
                } else {
                    width = args[0];
                    height = args[1];
                    angle = 0;
                }
            } else if (args.length === 3) {
                width = args[0];
                height = args[1];
                angle = args[2] || 0;
            }
            var wh = GD.getRatioWithRotation(0, width, height);
            this.setHeight(wh.ratioY);
            this.setWidth(wh.ratioX);
            return this;
        },
        getPosition: function () {
            return {
                x: this._x,
                y: this._y
            }
        },
        setPosition: function () {
            var args = Array.prototype.slice.call(arguments, 0), x, y;
            if (args.length === 0) {
                return this;
            } else if (args.length === 1) {
                if (typeof args[0] != 'object') {
                    return this;
                }
                x = args[0].x;
                y = args[0].y;
            } else {
                x = args[0];
                y = args[1];
            }
            if ((x !== 0 && !x) || (y !== 0 && !y)) {
                return this;
            }
            // var childNodes = this.childNodes, offset, childNode, p;
            // for (var i = 0, len = childNodes.length; i < len; i++) {
            //     childNode = childNodes[i];
            //     p = childNode.getPosition();
            //     childNode.setPosition(x - (this._x-p.x)*this._ratioX, y - (this._y-p.y)*this._ratioY);
            // }
            // this._x = x;
            // this._y = y;
            // return this;

            var childNodes, childNode, background, offset = {}, op, cp;

            childNodes = this.childNodes;
            background = this._background;
            op = background.getPosition();
            offset.x = x - op.x;
            offset.y = y - op.y;
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                cp = childNode.getPosition();
                childNode.setPosition(cp.x + offset.x, cp.y + offset.y);
            }
            this._x = x;
            this._y = y;
            this._position = {x: x, y: y};
            return this;
        },
        getStyle: function (key) {
            if (!key) {
                return undefined;
            }
            return this._styleObject[key];
        },
        setStyle: function (key, value, force) {
            var childNodes = this.childNodes, childNode;
            
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                if (key === '2d.visible') {
                    if (value === graphView.isVisible(childNode)) {
                        continue;
                    }
                    if (!value) {
                        childNode._savedIsVisible = graphView.isVisible(childNode);
                        childNode.s({
                            '2d.visible': false
                        })
                    } else {
                        childNode.s({
                            '2d.visible': childNode._savedIsVisible
                        })
                    }
                    continue;
                }
                childNode.s({
                    key: value
                });
            }
            this._styleObject[key] = value;
            return this;
        },
        calcSize: function () {
            var background = this._background;
            var position = background.getPosition(),
                width = background.getWidth(),
                height = background.getHeight();
            this._width = width;
            this._height = height;
            this._x = position.x;
            this._y = position.y;
            this._position = {
                x: this._x,
                y: this._y
            }
            return this;
            return this;
        },
        s: function (styleObj, force) {
            var args = Array.prototype.slice.call(arguments, 0);
            var styleObj;
            if (args.length === 0) {
                return this;
            } else if (args.length === 1) {
                styleObj = args[0];
            } else {
                this.setStyle(args[0], args[1]);
                return this;
            }
            for (var key in styleObj) {
                if (!styleObj.hasOwnProperty(key)) {
                    continue;
                }
                this.setStyle(key, styleObj[key], force);
            }
            return this;
        }, 
        init: function (x, y, width, height, angle) {
            var that = this;
            this.calcSize();
            (function (width, height, angle) {
                // that.setSize(width, height, angle);
                // var wh = GD.getRatioWithRotation(angle, width, height);
                // width = wh.ratioX;
                // height = wh.ratioY;
                var originHeight = that._height;
                var originWidth = that._width;
                var ratioY = height / originHeight;
                var ratioX = width / originWidth;
                var childNodes = that.childNodes,
                    childNode,p, op = that.getPosition(), h, ch, oy, w, cw, ox, name, borderRatio, borderWidth;
                for (var i = 0, len = childNodes.length; i < len; i++) {
                    childNode = childNodes[i];
                    p = childNode.getPosition();
                    childNode.originHeight = childNode.originHeight || childNode.getHeight();
                    ch = childNode.getHeight();
                    cw = childNode.getWidth();
                    
                    if (ch > 2) {
                        h = ch * ratioY;
                        childNode.setHeight(h);
                    } 
                    if (cw > 2) {
                        w = cw * ratioX;
                        childNode.setWidth(w);
                    }

                    borderRatio = (ratioX + ratioY)*0.5;
                    if (childNode._nodeType === 'line') { // 如果是线，
                        if (childNode.getWidth() > childNode.getHeight()) {
                            borderRatio = ratioX;
                        } else {
                            borderRatio = ratioY;
                        }
                    }

                    name = childNode._nodename;
                    // if (childNode.borderWidth && name && ch > 2 && cw > 2) {
                    //     borderWidth = childNode.borderWidth / borderRatio;
                    //     if (borderWidth > ch*0.5 || borderWidth > cw *0.5) {
                    //         // borderWidth = childNode.borderWidth;
                    //     }
                    //     childNode.borderWidth = borderWidth;
                    //     childNode.a(name + '.borderwidth', borderWidth);
                    // }
                }
                that._height = height;
                that._originHeight = height;
                that._ratioY = ratioY;
                that._width = width;
                that._originWidth = width;
                that._ratioX = ratioX;
            })(width, height, angle);
            that._x = width / 2;
            that._y = height / 2;
            that._rotation = 0;
            // that.setPosition(x, y);
            (function (x, y) {
                var childNodes = that.childNodes, offset, childNode;
                var w2 = that.getWidth() / 2, h2 = that.getHeight()/2;
                for (var i = 0, len = childNodes.length; i < len; i++) {
                    childNode = childNodes[i];
                    offset = childNode.getPosition();
                    childNode.setPosition(x + offset.x * that._ratioX - w2, y + offset.y * that._ratioY - h2);
                }
                that._x = x;
                that._y = y;
            })(x, y);
            // setTimeout(that.addEVent, 1000);
        },
        setRotation: function (angle) {
            var that = this, _angle = that.getRotation();
            if (angle!==0 && !angle || angle === _angle) {
                return this;
            }
            var childNodes = this.childNodes, childNode, p = this.getPosition(), px = p.x, py = p.y;
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                var x = childNode.getPosition().x - px;
                var y = childNode.getPosition().y - py;
                childNode.setPosition(Math.cos(angle-_angle) * x - Math.sin(angle-_angle) * y + px, Math.cos(angle-_angle) * y + Math.sin(angle-_angle) * x + py);
                childNode.setRotation(angle);
            }
            this._rotation = angle;
            return this;
        },
        getRotation: function () {
            return this._rotation;
        },
        setScale: function (sx, sy) {
            var that = this,
                childNodes = this.childNodes,
                childNode;
            if (sx === undefined || sx === null) return ;
            if (sy === undefined || sy === null) {
                sy = sx;
            }
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                if (typeof childNode.setScale === 'function') {
                    childNode.setScale(sx, sy);
                }
            }
        },
        getScale: function () {
            return this._background.getScale();
        },
        setScaleX: function (sx) {
            if (sx === undefined || sx === null) return;
            var that = this,
                childNodes = this.childNodes,
                childNode;
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                if (typeof childNode.setScaleX === 'function') {
                    childNode.setScaleX(sx);
                }
            }
        },
        setScaleY: function (sy) {
            if (sy === undefined || sy === null) return;
            var that = this,
                childNodes = this.childNodes,
                childNode;
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                if (typeof childNode.setScaleY === 'function') {
                    childNode.setScaleY(sy);
                }
            }
        },
        getScaleX: function () {
            return this._background.getScaleX();
        },
        getScaleY: function () {
            return this._background.getScaleY();
        },
        evert: function () {
            var that = this,
                childNodes = this.childNodes,
                background = this._background,
                bp = background.getPosition(),
                bx = bp.x,
                by = bp.y,
                childNode, distanceX, distanceY, x, y, p, nx, ny;
            
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                p = childNode.getPosition();
                x = p.x;
                y = p.y;
                distanceX = bx - x;
                distanceY = by - y;
                nx = bx + distanceX;
                ny = by + distanceY;
                childNode.setPosition(nx, ny);
                if (typeof childNode.setScale === 'function') {
                    if (!(childNode._disallowEvert === true))
                        childNode.setScale(-1, -1);
                }
            }
        },
        evertX: function () {
            var that = this,
                childNodes = this.childNodes,
                background = this._background,
                bx = background.getPosition().x,
                childNode, distance, x, p, nx;
            
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                p = childNode.getPosition();
                x = p.x;
                distance = bx - x;
                nx = bx + distance;
                childNode.setPosition(nx, p.y);
                if (typeof childNode.setScaleX === 'function') {
                    if (!(childNode._disallowEvert === true))
                        childNode.setScaleX(-1);
                }
            }
        },
        evertY: function () {
            var that = this,
                childNodes = this.childNodes,
                background = this._background,
                by = background.getPosition().y,
                childNode, distance, y, p, ny;
            
            for (var i = 0, len = childNodes.length; i < len; i++) {
                childNode = childNodes[i];
                p = childNode.getPosition();
                y = p.y;
                distance = by - y;
                ny = by + distance;
                childNode.setPosition(p.x, ny);
                if (typeof childNode.setScaleY === 'function') {
                    if (!(childNode._disallowEvert === true))
                        childNode.setScaleY(-1);
                }
            }
        },
        attr: function (key, value) {
            var _attrObj = this._attrObj || {};
            if (arguments.length === 1) {
                return _attrObj[key];
            }
            var childNodes = this.childNodes, childNode;
            _attrObj[key] = value;
            for (var i = 0; childNode = childNodes[i++];) {
                if (typeof childNode.a === 'function') {
                    childNode.a(key, value);
                }
            }
        },
        a: function () {
            return this.attr.apply(this, arguments);
        }
    });
}